package com.sg.service.biz.framework.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollectionUtil;
import com.sg.common.util.CommonFunctionHelper;
import com.sg.common.util.RedisUtil;
import com.sg.dto.base.framework.req.*;
import com.sg.dto.biz.framework.req.*;
import com.sg.dto.biz.framework.res.*;
import com.sg.service.biz.framework.PowerService;
import com.wicket.okrcomponent.integration.ConfSchemeService;
import com.wicket.okrcomponent.integration.InterfaceModeService;
import com.wicket.okrcomponent.integration.MessageService;
import com.wicket.okrcomponent.integration.dto.*;
import com.wicket.okrframework.common.annotations.BanAuto;
import com.sg.common.exception.Assert;
import com.wicket.okrframework.common.exception.BizException;
import com.wicket.okrframework.dal.po.mbg.*;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @author ：
 * @version 1.0
 * @date ：
 */
@Service
public class MemberServiceImpl
        implements com.wicket.okrframework.biz.service.MemberService {

    @Resource
    private RedisUtil redisUtil;
    @Resource
    private MInductionRecordService mInductionRecordService;
    @Resource
    private MOriginalRoleMemberService mOriginalRoleMemberService;
    @Resource
    private MUserinfoService mUserinfoService;
    @Resource
    private MOriginalRoleMemberInfoService mOriginalRoleMemberInfoService;
    @Resource
    private MRoleMemberService mRoleMemberService;
    @Resource
    private MUsersService mUsersService;
    @Resource
    private MSceneRoleService mSceneRoleService;
    // @Resource
    // private MSpecMethordTableService mSpecMethordTableService;
    @Resource
    private MOrganizationService mOrganizationService;
    @Resource
    private MSpaceMemberService mSpaceMemberService;
    @Resource
    private NbMember nbMember;
    @Resource
    private MManagedDeptService mManagedDeptService;
    @Resource
    private ConfSchemeService confSchemeService;
    @Resource
    private PowerService powerService;
    @Resource
    private MessageService fwCompMessageClient;
    @Resource
    private InterfaceModeService interfaceModeService;
//@Resource
    //private undefinedService undefinedService;
//@Resource
    //private MCustomFields2Service mCustomFields2Service;

    /**
     * D1-2查询组织下成员列表（边界）[1784]
     * gen by moon at 10/2/2022, 12:35:29 AM
     */
    @Trace(operationName = "D1-2查询组织下成员列表（边界）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryOrgMemberListBorderRespDto queryOrgMemberListBorder(QueryOrgMemberListBorderReqDto reqDto) {


        QueryMemberCollectionDataListRespDto collectionNDataRes_1 = null;
        List<Userinfo> listUserinfo_1 = new ArrayList<>();
        List<OriginalRoleMemberInfo> listOriginalRoleMemberInfo_1 = new ArrayList<>();
        if ((reqDto != null && reqDto.getOrganizationId() != null && reqDto != null && reqDto.getRoleCode() != null && reqDto.getRoleCode().equals("STAFF"))) {
            //if((D1-2查询组织下成员列表（边界）.组织ID 值不等于空  and D1-2查询组织下成员列表（边界）.角色标识 等于 员工))  2048

            List<InductionRecord> listInductionRecord = new ArrayList<>();
            QueryInductionRecordListReq queryInductionRecordListReq = new QueryInductionRecordListReq();
            queryInductionRecordListReq.setIsTransaction("FALSE");//sourceId:54282_1_2049
            queryInductionRecordListReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:54194_1_2049
            if (reqDto != null) {
                queryInductionRecordListReq.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:54193_1_2049
            }

            /*1-3-13查询就职记录列表（组织最新员工未去重）[166]   */
            Assert.isNull(queryInductionRecordListReq.getOrganizationId(), "D1-2查询组织下成员列表（边界）-1-3-13查询就职记录列表（组织最新员工未去重）-组织ID不能为空", false);
            Assert.isNull(queryInductionRecordListReq.getIsTransaction(), "D1-2查询组织下成员列表（边界）-1-3-13查询就职记录列表（组织最新员工未去重）-是否异动不能为空", false);
            Assert.isNull(queryInductionRecordListReq.getSubjectLifeCycle(), "D1-2查询组织下成员列表（边界）-1-3-13查询就职记录列表（组织最新员工未去重）-主体生命周期不能为空", false);
            listInductionRecord = mInductionRecordService.queryInductionRecordList(queryInductionRecordListReq);


            List<OriginalRoleMember> listOriginalRoleMember = new ArrayList<>();
            if (listInductionRecord != null && listInductionRecord.size() > 0) {
                BatchQueryBeginMemberListReq batchQueryBeginMemberListReq = new BatchQueryBeginMemberListReq();
                batchQueryBeginMemberListReq.setBeginMemberList(listInductionRecord.stream().map(item -> item.getOriginalRoleMemberId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:54206_1_2050
                batchQueryBeginMemberListReq.setIsTransaction("FALSE");//sourceId:54211_1_2050
                batchQueryBeginMemberListReq.setIsInvalid("FALSE");//sourceId:54209_1_2050
                batchQueryBeginMemberListReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:54210_1_2050
                if (reqDto != null) {
                    batchQueryBeginMemberListReq.setRoleCode("STAFF");//CUSTOM_CONVENTION//sourceId:54212_1_2050
                }

                /*1-2-09批量查询身份人员列表（自动去重身份员工）[1181] 非特殊方法  */
                Assert.isNull(batchQueryBeginMemberListReq.getRoleCode(), "D1-2查询组织下成员列表（边界）-1-2-09批量查询身份人员列表（自动去重身份员工）-身份角色编码不能为空", false);
                Assert.isNull(batchQueryBeginMemberListReq.getIsTransaction(), "D1-2查询组织下成员列表（边界）-1-2-09批量查询身份人员列表（自动去重身份员工）-是否异动不能为空", false);
                Assert.isNull(batchQueryBeginMemberListReq.getIsInvalid(), "D1-2查询组织下成员列表（边界）-1-2-09批量查询身份人员列表（自动去重身份员工）-是否失效不能为空", false);
                Assert.isNull(batchQueryBeginMemberListReq.getSubjectLifeCycle(), "D1-2查询组织下成员列表（边界）-1-2-09批量查询身份人员列表（自动去重身份员工）-主体生命周期不能为空", false);
                listOriginalRoleMember = mOriginalRoleMemberService.batchQueryBeginMemberList(batchQueryBeginMemberListReq);


            }
//ModelCode: collectionNData
            QueryMemberCollectionDataListRespDto collectionNDataRes = null;
            if (listOriginalRoleMember != null && listOriginalRoleMember.size() > 0) {
                QueryMemberCollectionDataListReqDto collectionNDataReq = new QueryMemberCollectionDataListReqDto();
                collectionNDataReq.setBeginMemberList(listOriginalRoleMember.stream().map(item -> BeanUtil.toBean(item, BeginMemberDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:54395_1_2062
                collectionNDataReq.setCollectionData(20L);//CUSTOM_CONVENTION//sourceId:54397_1_2062

                /*M-查询成员集合取x条数据（特殊方法）[1788]  入参数据集，取N条数据，出参数据集 */
                Assert.isNull(collectionNDataReq.getCollectionData(), "D1-2查询组织下成员列表（边界）-M-查询成员集合取x条数据（特殊方法）-取X条数不能为空", false);
                collectionNDataRes = nbMember.queryMemberCollectionDataList(collectionNDataReq);


                collectionNDataRes_1 = collectionNDataRes;
            }
            List<Userinfo> listUserinfo = new ArrayList<>();
            BatchQueryUserinfoListReq batchQueryUserinfoListReq = new BatchQueryUserinfoListReq();
            if (collectionNDataRes != null) {
                batchQueryUserinfoListReq.setUserList(collectionNDataRes.getBeginMemberList().stream().map(item -> item.getUserId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:54225_1_2051
            }

            /*1-2-02批量查询个人资料列表[52]   */

            listUserinfo = mUserinfoService.batchQueryUserinfoList(batchQueryUserinfoListReq);


            listUserinfo_1 = listUserinfo;
            List<OriginalRoleMemberInfo> listOriginalRoleMemberInfo = new ArrayList<>();
            BatchQueryBeginMembInfoListReq batchQueryBeginMembInfoListReq = new BatchQueryBeginMembInfoListReq();
            if (collectionNDataRes != null) {
                batchQueryBeginMembInfoListReq.setBeginMembInfoList(collectionNDataRes.getBeginMemberList().stream().map(item -> item.getOriginalRoleMemberId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:56484_1_2196
            }

            /*1-2-10批量查询身份人员资料列表[1014]   */

            listOriginalRoleMemberInfo = mOriginalRoleMemberInfoService.batchQueryBeginMembInfoList(batchQueryBeginMembInfoListReq);


            listOriginalRoleMemberInfo_1 = listOriginalRoleMemberInfo;
//processBranchName:正常结束 ,processBranchId:2052

        } else if ((reqDto != null && reqDto.getOrganizationId() != null) && (reqDto != null && reqDto.getRoleCode() != null && reqDto.getRoleCode().equals("ADMIN") || reqDto != null && reqDto.getRoleCode() != null && reqDto.getRoleCode().equals("DEPT_LEADER"))) {
            //elseif(D1-2查询组织下成员列表（边界）.组织ID 值不等于空  and (D1-2查询组织下成员列表（边界）.角色标识 等于 空间管理员 or D1-2查询组织下成员列表（边界）.角色标识 等于 分管领导))  2053

            List<RoleMember> listRoleMember = new ArrayList<>();
            QueryRoleRelListReq queryRoleRelListReq = new QueryRoleRelListReq();
            queryRoleRelListReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:54251_1_2054
            queryRoleRelListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:54252_1_2054
            if (reqDto != null) {
                queryRoleRelListReq.setRoleCode(reqDto.getRoleCode());//SimpleFieldAssign//sourceId:54250_1_2054
            }

            /*1-2-13查询角色人员列表（查员工未去重）[334]   */
            Assert.isNull(queryRoleRelListReq.getRoleCode(), "D1-2查询组织下成员列表（边界）-1-2-13查询角色人员列表（查员工未去重）-角色标识不能为空", false);
            Assert.isNull(queryRoleRelListReq.getSubjectLifeCycle(), "D1-2查询组织下成员列表（边界）-1-2-13查询角色人员列表（查员工未去重）-主体生命周期不能为空", false);
            Assert.isNull(queryRoleRelListReq.getSpaceId(), "D1-2查询组织下成员列表（边界）-1-2-13查询角色人员列表（查员工未去重）-创建于空间ID不能为空", false);
            listRoleMember = mRoleMemberService.queryRoleRelList(queryRoleRelListReq);


            List<InductionRecord> listInductionRecord_2 = new ArrayList<>();
            if (listRoleMember != null && listRoleMember.size() > 0) {
                BatchQueryInductionRecordListByIdsReq batchQueryInductionRecordListByIdsReq = new BatchQueryInductionRecordListByIdsReq();
                batchQueryInductionRecordListByIdsReq.setOrgStaffList(listRoleMember.stream().map(item -> item.getOriginalRoleMemberId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:54261_1_2055
                batchQueryInductionRecordListByIdsReq.setIsTransaction("FALSE");//sourceId:54281_1_2055
                batchQueryInductionRecordListByIdsReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:54274_1_2055
                if (reqDto != null) {
                    batchQueryInductionRecordListByIdsReq.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:54265_1_2055
                }

                /*1-3-13批量查询就职记录列表By身份ID[1598]   */
                Assert.isNull(batchQueryInductionRecordListByIdsReq.getOrganizationId(), "D1-2查询组织下成员列表（边界）-1-3-13批量查询就职记录列表By身份ID-组织ID不能为空", false);
                Assert.isNull(batchQueryInductionRecordListByIdsReq.getIsTransaction(), "D1-2查询组织下成员列表（边界）-1-3-13批量查询就职记录列表By身份ID-是否异动不能为空", false);
                Assert.isNull(batchQueryInductionRecordListByIdsReq.getSubjectLifeCycle(), "D1-2查询组织下成员列表（边界）-1-3-13批量查询就职记录列表By身份ID-主体生命周期不能为空", false);
                listInductionRecord_2 = mInductionRecordService.batchQueryInductionRecordListByIds(batchQueryInductionRecordListByIdsReq);


            }
            List<OriginalRoleMember> listOriginalRoleMember_2 = new ArrayList<>();
            if (listInductionRecord_2 != null && listInductionRecord_2.size() > 0) {
                BatchQueryBeginMemberListReq batchQueryBeginMemberListReq_1 = new BatchQueryBeginMemberListReq();
                batchQueryBeginMemberListReq_1.setBeginMemberList(listInductionRecord_2.stream().map(item -> item.getOriginalRoleMemberId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:54206_1_2056
                batchQueryBeginMemberListReq_1.setRoleCode("STAFF");//CUSTOM_CONVENTION//sourceId:54212_1_2056
                batchQueryBeginMemberListReq_1.setIsTransaction("FALSE");//sourceId:54211_1_2056
                batchQueryBeginMemberListReq_1.setIsInvalid("FALSE");//sourceId:54209_1_2056
                batchQueryBeginMemberListReq_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:54210_1_2056

                /*1-2-09批量查询身份人员列表（自动去重身份员工）[1181] 非特殊方法  */
                Assert.isNull(batchQueryBeginMemberListReq_1.getRoleCode(), "D1-2查询组织下成员列表（边界）-1-2-09批量查询身份人员列表（自动去重身份员工）-身份角色编码不能为空", false);
                Assert.isNull(batchQueryBeginMemberListReq_1.getIsTransaction(), "D1-2查询组织下成员列表（边界）-1-2-09批量查询身份人员列表（自动去重身份员工）-是否异动不能为空", false);
                Assert.isNull(batchQueryBeginMemberListReq_1.getIsInvalid(), "D1-2查询组织下成员列表（边界）-1-2-09批量查询身份人员列表（自动去重身份员工）-是否失效不能为空", false);
                Assert.isNull(batchQueryBeginMemberListReq_1.getSubjectLifeCycle(), "D1-2查询组织下成员列表（边界）-1-2-09批量查询身份人员列表（自动去重身份员工）-主体生命周期不能为空", false);
                listOriginalRoleMember_2 = mOriginalRoleMemberService.batchQueryBeginMemberList(batchQueryBeginMemberListReq_1);


            }
//ModelCode: collectionNData
            QueryMemberCollectionDataListRespDto collectionNDataRes_2 = null;
            if (listOriginalRoleMember_2 != null && listOriginalRoleMember_2.size() > 0) {
                QueryMemberCollectionDataListReqDto collectionNDataReq_1 = new QueryMemberCollectionDataListReqDto();
                collectionNDataReq_1.setBeginMemberList(listOriginalRoleMember_2.stream().map(item -> BeanUtil.toBean(item, BeginMemberDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:54395_1_2063
                collectionNDataReq_1.setCollectionData(20L);//CUSTOM_CONVENTION//sourceId:54397_1_2063

                /*M-查询成员集合取x条数据（特殊方法）[1788]  入参数据集，取N条数据，出参数据集 */
                Assert.isNull(collectionNDataReq_1.getCollectionData(), "D1-2查询组织下成员列表（边界）-M-查询成员集合取x条数据（特殊方法）-取X条数不能为空", false);
                collectionNDataRes_2 = nbMember.queryMemberCollectionDataList(collectionNDataReq_1);


                collectionNDataRes_1 = collectionNDataRes_2;
            }
            List<Userinfo> listUserinfo_2 = new ArrayList<>();
            BatchQueryUserinfoListReq batchQueryUserinfoListReq_1 = new BatchQueryUserinfoListReq();
            if (collectionNDataRes_2 != null) {
                batchQueryUserinfoListReq_1.setUserList(collectionNDataRes_2.getBeginMemberList().stream().map(item -> item.getUserId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:54225_1_2057
            }

            /*1-2-02批量查询个人资料列表[52]   */

            listUserinfo_2 = mUserinfoService.batchQueryUserinfoList(batchQueryUserinfoListReq_1);


            listUserinfo_1 = listUserinfo_2;
            List<OriginalRoleMemberInfo> listOriginalRoleMemberInfo_2 = new ArrayList<>();
            BatchQueryBeginMembInfoListReq batchQueryBeginMembInfoListReq_1 = new BatchQueryBeginMembInfoListReq();
            if (collectionNDataRes_2 != null) {
                batchQueryBeginMembInfoListReq_1.setBeginMembInfoList(collectionNDataRes_2.getBeginMemberList().stream().map(item -> item.getOriginalRoleMemberId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:56484_1_2197
            }

            /*1-2-10批量查询身份人员资料列表[1014]   */

            listOriginalRoleMemberInfo_2 = mOriginalRoleMemberInfoService.batchQueryBeginMembInfoList(batchQueryBeginMembInfoListReq_1);


            listOriginalRoleMemberInfo_1 = listOriginalRoleMemberInfo_2;
//processBranchName:正常结束 ,processBranchId:2058

        } else {
            //else  2060

//异常结束 2061
            throw new BizException("C00029", "对不起，异常错误，不可操作～！", false);
        }
        QueryOrgMemberListBorderRespDto retData = new QueryOrgMemberListBorderRespDto();
        //数据集融合  MoreListToOneSource
        if (collectionNDataRes_1 != null && !CollectionUtil.isEmpty(collectionNDataRes_1.getBeginMemberList())) {
            for (BeginMemberDto beginMemberDto : collectionNDataRes_1.getBeginMemberList()) {
                BeginMemberDto retElm = new BeginMemberDto();
                if (collectionNDataRes_1 != null) {
                    retElm.setOriginalRoleMemberId(beginMemberDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:29501_2
                    retElm.setUserId(beginMemberDto.getUserId());//SimpleFieldAssign//sourceId:29502_2
                }
                retData.getBeginMemberList().add(retElm);
                if (listUserinfo_1 != null) {
                    for (Userinfo userinfo : listUserinfo_1) {
                        if (userinfo.getUserId().equals(beginMemberDto.getUserId())) {
                            retElm.setIdCardName(userinfo.getIdCardName());//SimpleFieldAssign//sourceId:29503_2
                            retElm.setNickName(userinfo.getNickName());//SimpleFieldAssign//sourceId:29504_2
                            retElm.setUserFace(userinfo.getUserFace());//SimpleFieldAssign//sourceId:29505_2
                        }
                    }
                }

                if (listOriginalRoleMemberInfo_1 != null) {
                    for (OriginalRoleMemberInfo originalRoleMemberInfo : listOriginalRoleMemberInfo_1) {
                        if (originalRoleMemberInfo.getOriginalRoleMemberId().equals(beginMemberDto.getOriginalRoleMemberId())) {
                            retElm.setPositionIdName(originalRoleMemberInfo.getPositionIdName());//SimpleFieldAssign//sourceId:30967_2
                        }
                    }
                }

            }
        }//sourceId:54361_1


        return retData;
    }

    /**
     * D1-2查询角色人员列表（边界）[1708]
     * gen by moon at 11/1/2022, 7:47:42 AM
     */
    @Trace(operationName = "D1-2查询角色人员列表（边界）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryRoleRelListBorderRespDto queryRoleRelListBorder(QueryRoleRelListBorderReqDto reqDto) {


        List<Userinfo> listUserinfo_1 = new ArrayList<>();
        List<RoleMember> listRoleMember_1 = new ArrayList<>();
        List<OriginalRoleMemberInfo> listOriginalRoleMemberInfo_1 = new ArrayList<>();
        List<Userinfo> listUserinfo_3 = new ArrayList<>();
        List<RoleMember> listRoleMember_3 = new ArrayList<>();
        if ((reqDto != null && reqDto.getIdCardName() != null)) {
            //if(D1-2查询角色人员列表（边界）.真实姓名 不等于空 )  1746

            List<Userinfo> listUserinfo = new ArrayList<>();
            QueryUserInfoListReq queryUserInfoListReq = new QueryUserInfoListReq();
            if (reqDto != null) {
                queryUserInfoListReq.setFirstLetter(reqDto.getFirstLetter());//SimpleFieldAssign//sourceId:99212_1_1748
                queryUserInfoListReq.setIdCardName(reqDto.getIdCardName());//SimpleFieldAssign//sourceId:51148_1_1748
            }

            /*1-2-02查询个人资料列表（真实姓名搜索）[1178]   */

            listUserinfo = mUserinfoService.queryUserInfoList(queryUserInfoListReq);


            listUserinfo_1 = listUserinfo;
            List<RoleMember> listRoleMember = new ArrayList<>();
            if (listUserinfo != null && !CollectionUtil.isEmpty(listUserinfo) && listUserinfo.size() > 0) {
                BatchQueryRoleRelListByIdsReq batchQueryRoleRelListByIdsReq = new BatchQueryRoleRelListByIdsReq();
                batchQueryRoleRelListByIdsReq.setRoleRelList(listUserinfo.stream().map(item -> item.getUserId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:51171_1_1749
                if (reqDto != null) {
                    batchQueryRoleRelListByIdsReq.setRoleCode(reqDto.getRoleCode());//SimpleFieldAssign//sourceId:51173_1_1749
                    batchQueryRoleRelListByIdsReq.setRelationshipValid(reqDto.getRelationshipValid());//SimpleFieldAssign//sourceId:51174_1_1749
                    batchQueryRoleRelListByIdsReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:51175_1_1749
                    batchQueryRoleRelListByIdsReq.setIsArchive(reqDto.getIsArchive());//SimpleFieldAssign//sourceId:51176_1_1749
                    batchQueryRoleRelListByIdsReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:51178_1_1749
                }

                /*1-2-09批量查询角色人员列表By账号ID[1709]   */
                Assert.isNull(batchQueryRoleRelListByIdsReq.getRoleCode(), "D1-2查询角色人员列表（边界）-1-2-09批量查询角色人员列表By账号ID-角色标识不能为空", false);
                listRoleMember = mRoleMemberService.batchQueryRoleRelListByIds(batchQueryRoleRelListByIdsReq);


                listRoleMember_1 = listRoleMember;
            }
            List<OriginalRoleMemberInfo> listOriginalRoleMemberInfo = new ArrayList<>();
            if (listRoleMember != null && !CollectionUtil.isEmpty(listRoleMember) && listRoleMember.size() > 0) {
                BatchQueryBeginMembInfoListReq batchQueryBeginMembInfoListReq = new BatchQueryBeginMembInfoListReq();
                batchQueryBeginMembInfoListReq.setBeginMembInfoList(listRoleMember.stream().map(item -> item.getOriginalRoleMemberId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:51209_1_1758

                /*1-2-10批量查询身份人员资料列表[1014]   */

                listOriginalRoleMemberInfo = mOriginalRoleMemberInfoService.batchQueryBeginMembInfoList(batchQueryBeginMembInfoListReq);


                listOriginalRoleMemberInfo_1 = listOriginalRoleMemberInfo;
            }
            List<Userinfo> listUserinfo_2 = new ArrayList<>();
            if (listRoleMember != null && !CollectionUtil.isEmpty(listRoleMember) && listRoleMember.size() > 0) {
                BatchQueryUserinfoListReq batchQueryUserinfoListReq = new BatchQueryUserinfoListReq();
                batchQueryUserinfoListReq.setUserList(listRoleMember.stream().map(item -> item.getUserId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:51210_1_1759

                /*1-2-02批量查询个人资料列表[52]   */

                listUserinfo_2 = mUserinfoService.batchQueryUserinfoList(batchQueryUserinfoListReq);


                listUserinfo_3 = listUserinfo_2;
            }
//processBranchName:正常结束 ,processBranchId:1763

        } else {
            //else  1747

            List<RoleMember> listRoleMember_2 = new ArrayList<>();
            QueryRoleRelListReq queryRoleRelListReq = new QueryRoleRelListReq();
            if (reqDto != null) {
                queryRoleRelListReq.setRoleCode(reqDto.getRoleCode());//SimpleFieldAssign//sourceId:51189_1_1752
                queryRoleRelListReq.setRelationshipValid(reqDto.getRelationshipValid());//SimpleFieldAssign//sourceId:51190_1_1752
                queryRoleRelListReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:51194_1_1752
                queryRoleRelListReq.setIsArchive(reqDto.getIsArchive());//SimpleFieldAssign//sourceId:51195_1_1752
                queryRoleRelListReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:51204_1_1752
            }

            /*1-2-13查询角色人员列表（非搜索）[334]   */
            Assert.isNull(queryRoleRelListReq.getRoleCode(), "D1-2查询角色人员列表（边界）-1-2-13查询角色人员列表（非搜索）-角色标识不能为空", false);
            listRoleMember_2 = mRoleMemberService.queryRoleRelList(queryRoleRelListReq);


            listRoleMember_3 = listRoleMember_2;
            List<OriginalRoleMemberInfo> listOriginalRoleMemberInfo_2 = new ArrayList<>();
            if (listRoleMember_2 != null && !CollectionUtil.isEmpty(listRoleMember_2) && listRoleMember_2.size() > 0) {
                BatchQueryBeginMembInfoListReq batchQueryBeginMembInfoListReq_1 = new BatchQueryBeginMembInfoListReq();
                batchQueryBeginMembInfoListReq_1.setBeginMembInfoList(listRoleMember_2.stream().map(item -> item.getOriginalRoleMemberId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:51209_1_1761

                /*1-2-10批量查询身份人员资料列表[1014]   */

                listOriginalRoleMemberInfo_2 = mOriginalRoleMemberInfoService.batchQueryBeginMembInfoList(batchQueryBeginMembInfoListReq_1);


                listOriginalRoleMemberInfo_1 = listOriginalRoleMemberInfo_2;
            }
            List<Userinfo> listUserinfo_4 = new ArrayList<>();
            if (listRoleMember_2 != null && !CollectionUtil.isEmpty(listRoleMember_2) && listRoleMember_2.size() > 0) {
                BatchQueryUserinfoListReq batchQueryUserinfoListReq_1 = new BatchQueryUserinfoListReq();
                batchQueryUserinfoListReq_1.setUserList(listRoleMember_2.stream().map(item -> item.getUserId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:51210_1_1762

                /*1-2-02批量查询个人资料列表[52]   */

                listUserinfo_4 = mUserinfoService.batchQueryUserinfoList(batchQueryUserinfoListReq_1);


                listUserinfo_3 = listUserinfo_4;
            }
//processBranchName:正常结束 ,processBranchId:1764

        }
        QueryRoleRelListBorderRespDto retData = new QueryRoleRelListBorderRespDto();
        //数据集融合  MoreListToOneSource
        if (listRoleMember_1 != null && !CollectionUtil.isEmpty(listRoleMember_1) && !CollectionUtil.isEmpty(listRoleMember_1)) {
            for (RoleMember roleMember : listRoleMember_1) {
                RoleRelDto retElm = new RoleRelDto();
                retElm.setRoleMemberId(roleMember.getRoleMemberId());//SimpleFieldAssign//sourceId:26747_2
                retElm.setOriginalRoleMemberId(roleMember.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:96476_2
                retElm.setRoleCode(roleMember.getRoleCode());//SimpleFieldAssign//sourceId:26751_2
                retElm.setUserId(roleMember.getUserId());//SimpleFieldAssign//sourceId:26748_2
//todo Cannot read properties of undefined (reading 'getInvokeSrc')
                retElm.setFirstLetter(roleMember.getFirstLetter());//SimpleFieldAssign//sourceId:26753_2
                retData.getRoleRelList().add(retElm);
                if (listUserinfo_3 != null && !CollectionUtil.isEmpty(listUserinfo_3)) {
                    for (Userinfo userinfo : listUserinfo_3) {
                        if (userinfo.getUserId().equals(roleMember.getUserId())) {
                            //todo Cannot read properties of undefined (reading 'getInvokeSrc')
                            retElm.setIdCardName(userinfo.getIdCardName());//SimpleFieldAssign//sourceId:26785_2
                            retElm.setNickName(userinfo.getNickName());//SimpleFieldAssign//sourceId:26786_2
                            retElm.setUserFace(userinfo.getUserFace());//SimpleFieldAssign//sourceId:26788_2
                        }
                    }
                }

                if (listOriginalRoleMemberInfo_1 != null && !CollectionUtil.isEmpty(listOriginalRoleMemberInfo_1)) {
                    for (OriginalRoleMemberInfo originalRoleMemberInfo : listOriginalRoleMemberInfo_1) {
                        if (originalRoleMemberInfo.getOriginalRoleMemberId().equals(roleMember.getOriginalRoleMemberId())) {
                            //todo Cannot read properties of undefined (reading 'getInvokeSrc')
                            retElm.setRoleMemberCode(originalRoleMemberInfo.getRoleMemberCode());//SimpleFieldAssign//sourceId:26784_2
                            retElm.setPositionIdName(originalRoleMemberInfo.getPositionIdName());//SimpleFieldAssign//sourceId:26787_2
                        }
                    }
                }

            }
        }
//数据集融合  MoreListToOneSource
        if (listRoleMember_3 != null && !CollectionUtil.isEmpty(listRoleMember_3) && !CollectionUtil.isEmpty(listRoleMember_3)) {
            for (RoleMember roleMember : listRoleMember_3) {
                RoleRelDto retElm = new RoleRelDto();
                retElm.setRoleMemberId(roleMember.getRoleMemberId());//SimpleFieldAssign//sourceId:26747_2
                retElm.setOriginalRoleMemberId(roleMember.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:96476_2
                retElm.setRoleCode(roleMember.getRoleCode());//SimpleFieldAssign//sourceId:26751_2
                retElm.setUserId(roleMember.getUserId());//SimpleFieldAssign//sourceId:26748_2
//todo Cannot read properties of undefined (reading 'getInvokeSrc')
                retElm.setFirstLetter(roleMember.getFirstLetter());//SimpleFieldAssign//sourceId:26753_2
                retData.getRoleRelList().add(retElm);
                if (listUserinfo_3 != null && !CollectionUtil.isEmpty(listUserinfo_3)) {
                    for (Userinfo userinfo : listUserinfo_3) {
                        if (userinfo.getUserId().equals(roleMember.getUserId())) {
                            //todo Cannot read properties of undefined (reading 'getInvokeSrc')
                            retElm.setIdCardName(userinfo.getIdCardName());//SimpleFieldAssign//sourceId:26785_2
                            retElm.setNickName(userinfo.getNickName());//SimpleFieldAssign//sourceId:26786_2
                            retElm.setUserFace(userinfo.getUserFace());//SimpleFieldAssign//sourceId:26788_2
                        }
                    }
                }

                if (listOriginalRoleMemberInfo_1 != null && !CollectionUtil.isEmpty(listOriginalRoleMemberInfo_1)) {
                    for (OriginalRoleMemberInfo originalRoleMemberInfo : listOriginalRoleMemberInfo_1) {
                        if (originalRoleMemberInfo.getOriginalRoleMemberId().equals(roleMember.getOriginalRoleMemberId())) {
                            //todo Cannot read properties of undefined (reading 'getInvokeSrc')
                            retElm.setRoleMemberCode(originalRoleMemberInfo.getRoleMemberCode());//SimpleFieldAssign//sourceId:26784_2
                            retElm.setPositionIdName(originalRoleMemberInfo.getPositionIdName());//SimpleFieldAssign//sourceId:26787_2
                        }
                    }
                }

            }
        }//sourceId:51225_1


        return retData;
    }

    /**
     * D1-2取消设员工无效[1690]
     * gen by moon at 2/24/2024, 6:43:31 PM
     */
    @Trace(operationName = "D1-2取消设员工无效")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public CancelIsinvalidSetStaffMemberRespDto cancelIsinvalidSetStaffMember(CancelIsinvalidSetStaffMemberReqDto reqDto) {


        //步骤0: 1-2-09修改身份人员 - updateBeginMember
        boolean bOOLEAN;
        OriginalRoleMember originalRoleMember = new OriginalRoleMember();
        originalRoleMember.setIsTransaction("FALSE");//sourceId:50312_1
        originalRoleMember.setIsInvalid("FALSE");//sourceId:50307_1
        if (reqDto != null) {
            originalRoleMember.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:50302_1
        }

        /*1-2-09修改身份人员[78]   */
        Assert.isNull(originalRoleMember.getOriginalRoleMemberId(), "D1-2取消设员工无效-1-2-09修改身份人员-身份人员ID不能为空", false);
        Assert.isNull(originalRoleMember.getIsTransaction(), "D1-2取消设员工无效-1-2-09修改身份人员-是否异动不能为空", false);
        Assert.isNull(originalRoleMember.getIsInvalid(), "D1-2取消设员工无效-1-2-09修改身份人员-是否失效不能为空", false);
        bOOLEAN = mOriginalRoleMemberService.updateBeginMember(originalRoleMember)/*vcase invoke 本地 method 方法调用;*/;


//步骤1: 1-3-13查询就职记录列表 - queryInductionRecordList
        List<InductionRecord> listInductionRecord = new ArrayList<>();
        QueryInductionRecordListReq queryInductionRecordListReq = new QueryInductionRecordListReq();
        queryInductionRecordListReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:50351_1
        queryInductionRecordListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:50352_1
        if (reqDto != null) {
            queryInductionRecordListReq.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:50350_1
        }

        /*1-3-13查询就职记录列表（查当前有效）[166]   */
        Assert.isNull(queryInductionRecordListReq.getOriginalRoleMemberId(), "D1-2取消设员工无效-1-3-13查询就职记录列表（查当前有效）-身份人员ID不能为空", false);
        Assert.isNull(queryInductionRecordListReq.getSubjectLifeCycle(), "D1-2取消设员工无效-1-3-13查询就职记录列表（查当前有效）-主体生命周期不能为空", false);
        Assert.isNull(queryInductionRecordListReq.getSpaceId(), "D1-2取消设员工无效-1-3-13查询就职记录列表（查当前有效）-创建于空间ID不能为空", false);
        listInductionRecord = mInductionRecordService.queryInductionRecordList(queryInductionRecordListReq)/*vcase invoke 本地 method 方法调用;*/;


//步骤2: 1-3-13批量修改就职记录 - batchUpdateInductionRecord
        boolean bOOLEAN_1;
        if (listInductionRecord != null && !CollectionUtil.isEmpty(listInductionRecord) && listInductionRecord.size() > 0) {
            List<InductionRecord> listInductionRecord_2 = new ArrayList<>();
            if (listInductionRecord != null && !CollectionUtil.isEmpty(listInductionRecord) && listInductionRecord != null && !CollectionUtil.isEmpty(listInductionRecord)) {
                listInductionRecord_2 = listInductionRecord.stream().map(item -> {
                    InductionRecord elm = BeanUtil.toBean(item, InductionRecord.class);
                    elm.setIsTransaction("FALSE");

                    return elm;
                }).collect(Collectors.toList());//objList-to-objLists//sourceId:50345_1
            }

            /*1-3-13批量修改就职记录[1647]   */

            bOOLEAN_1 = mInductionRecordService.batchUpdateInductionRecord(listInductionRecord_2)/*vcase invoke 本地 method 方法调用;*/;


        }

//步骤3: 1-2-13查询角色人员列表 - queryRoleRelList
        List<RoleMember> listRoleMember = new ArrayList<>();
        QueryRoleRelListReq queryRoleRelListReq = new QueryRoleRelListReq();
        queryRoleRelListReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:50597_1
        queryRoleRelListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:50598_1
        if (reqDto != null) {
            queryRoleRelListReq.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:50596_1
        }

        /*1-2-13查询角色人员列表[334]   */
        Assert.isNull(queryRoleRelListReq.getOriginalRoleMemberId(), "D1-2取消设员工无效-1-2-13查询角色人员列表-身份人员ID不能为空", false);
        Assert.isNull(queryRoleRelListReq.getSubjectLifeCycle(), "D1-2取消设员工无效-1-2-13查询角色人员列表-主体生命周期不能为空", false);
        Assert.isNull(queryRoleRelListReq.getSpaceId(), "D1-2取消设员工无效-1-2-13查询角色人员列表-创建于空间ID不能为空", false);
        listRoleMember = mRoleMemberService.queryRoleRelList(queryRoleRelListReq)/*vcase invoke 本地 method 方法调用;*/;


//步骤4: 1-2-13批量修改角色人员 - batchUpdateRoleRel
        boolean bOOLEAN_2;
        if (listRoleMember != null && !CollectionUtil.isEmpty(listRoleMember) && listRoleMember.size() > 0) {
            List<RoleMember> listRoleMember_2 = new ArrayList<>();
            if (listRoleMember != null && !CollectionUtil.isEmpty(listRoleMember) && listRoleMember != null && !CollectionUtil.isEmpty(listRoleMember)) {
                listRoleMember_2 = listRoleMember.stream().map(item -> {
                    RoleMember elm = BeanUtil.toBean(item, RoleMember.class);
                    elm.setRelationshipValid("FALSE");

                    return elm;
                }).collect(Collectors.toList());//objList-to-objLists//sourceId:50600_1
            }

            /*1-2-13批量修改角色人员[1560]   */

            bOOLEAN_2 = mRoleMemberService.batchUpdateRoleRel(listRoleMember_2)/*vcase invoke 本地 method 方法调用;*/;


        }

        CancelIsinvalidSetStaffMemberRespDto retData = new CancelIsinvalidSetStaffMemberRespDto();


        return retData;
    }

    /**
     * D1-2设员工无效[1688]
     * gen by moon at 10/2/2022, 12:19:37 AM
     */
    @Trace(operationName = "D1-2设员工无效")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public InValidIsinvalidSetStaffMemberRespDto inValidIsinvalidSetStaffMember(InValidIsinvalidSetStaffMemberReqDto reqDto) {


        //步骤0: 1-2-09修改身份人员 - updateBeginMember
        boolean bOOLEAN;
        OriginalRoleMember originalRoleMember = new OriginalRoleMember();
        originalRoleMember.setIsTransaction("TRUE");//sourceId:50033_1
        originalRoleMember.setIsInvalid("TRUE");//sourceId:50028_1
        originalRoleMember.setInvalidTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:50030_1
        if (reqDto != null) {
            originalRoleMember.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:50023_1
            originalRoleMember.setInvalidType(reqDto.getInvalidType());//SimpleFieldAssign//sourceId:50027_1
            originalRoleMember.setInvalidReason(reqDto.getInvalidReason());//SimpleFieldAssign//sourceId:50029_1
        }

        /*1-2-09修改身份人员[78]   */
        Assert.isNull(originalRoleMember.getIsTransaction(), "D1-2设员工无效-1-2-09修改身份人员-是否异动不能为空", false);
        Assert.isNull(originalRoleMember.getIsInvalid(), "D1-2设员工无效-1-2-09修改身份人员-是否失效不能为空", false);
        Assert.isNull(originalRoleMember.getInvalidTime(), "D1-2设员工无效-1-2-09修改身份人员-失效时间不能为空", false);
        bOOLEAN = mOriginalRoleMemberService.updateBeginMember(originalRoleMember);


//步骤1: 1-3-13查询就职记录列表 - queryInductionRecordList
        List<InductionRecord> listInductionRecord = new ArrayList<>();
        QueryInductionRecordListReq queryInductionRecordListReq = new QueryInductionRecordListReq();
        queryInductionRecordListReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:50090_1
        queryInductionRecordListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:50091_1
        if (reqDto != null) {
            queryInductionRecordListReq.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:50089_1
        }

        /*1-3-13查询就职记录列表（查当前有效）[166]   */
        Assert.isNull(queryInductionRecordListReq.getOriginalRoleMemberId(), "D1-2设员工无效-1-3-13查询就职记录列表（查当前有效）-身份人员ID不能为空", false);
        Assert.isNull(queryInductionRecordListReq.getSubjectLifeCycle(), "D1-2设员工无效-1-3-13查询就职记录列表（查当前有效）-主体生命周期不能为空", false);
        Assert.isNull(queryInductionRecordListReq.getSpaceId(), "D1-2设员工无效-1-3-13查询就职记录列表（查当前有效）-创建于空间ID不能为空", false);
        listInductionRecord = mInductionRecordService.queryInductionRecordList(queryInductionRecordListReq);


//步骤2: 1-3-13批量修改就职记录 - batchUpdateInductionRecord
        boolean bOOLEAN_1;
        if (listInductionRecord != null && listInductionRecord.size() > 0) {
            List<InductionRecord> listInductionRecord_2 = new ArrayList<>();
            listInductionRecord_2 = listInductionRecord.stream().map(item -> {
                InductionRecord elm = BeanUtil.toBean(item, InductionRecord.class);
                elm.setIsTransaction("TRUE");

                return elm;
            }).collect(Collectors.toList());//objList-to-objLists//sourceId:50088_1

            /*1-3-13批量修改就职记录（设异动）[1647]   */

            bOOLEAN_1 = mInductionRecordService.batchUpdateInductionRecord(listInductionRecord_2);


        }

//步骤3: 1-2-13查询角色人员列表 - queryRoleRelList
        List<RoleMember> listRoleMember = new ArrayList<>();
        QueryRoleRelListReq queryRoleRelListReq = new QueryRoleRelListReq();
        queryRoleRelListReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:50568_1
        queryRoleRelListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:50569_1
        if (reqDto != null) {
            queryRoleRelListReq.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:50567_1
        }

        /*1-2-13查询角色人员列表[334]   */
        Assert.isNull(queryRoleRelListReq.getOriginalRoleMemberId(), "D1-2设员工无效-1-2-13查询角色人员列表-身份人员ID不能为空", false);
        Assert.isNull(queryRoleRelListReq.getSubjectLifeCycle(), "D1-2设员工无效-1-2-13查询角色人员列表-主体生命周期不能为空", false);
        Assert.isNull(queryRoleRelListReq.getSpaceId(), "D1-2设员工无效-1-2-13查询角色人员列表-创建于空间ID不能为空", false);
        listRoleMember = mRoleMemberService.queryRoleRelList(queryRoleRelListReq);


//步骤4: 1-2-13批量修改角色人员 - batchUpdateRoleRel
        boolean bOOLEAN_2;
        if (listRoleMember != null && listRoleMember.size() > 0) {
            List<RoleMember> listRoleMember_2 = new ArrayList<>();
            listRoleMember_2 = //objList-to-objLists
                    listRoleMember.stream().map(item -> {
                        RoleMember elm = new RoleMember();
                        elm.setRoleMemberId(item.getRoleMemberId());//SimpleFieldAssign//sourceId:25929_2
                        elm.setRelationshipValid("TRUE");//sourceId:25938_2
                        elm.setInvalidTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:25941_2
                        if (reqDto != null) {
                            elm.setStatus(reqDto.getInvalidType());//SimpleFieldAssign//sourceId:25939_2
                            elm.setInvalidReason(reqDto.getInvalidReason());//SimpleFieldAssign//sourceId:25940_2
                        }
                        return elm;
                    }).collect(Collectors.toList());//objList-to-objLists//sourceId:50571_1

            /*1-2-13批量修改角色人员[1560]   */

            bOOLEAN_2 = mRoleMemberService.batchUpdateRoleRel(listRoleMember_2);


        }

        InValidIsinvalidSetStaffMemberRespDto retData = new InValidIsinvalidSetStaffMemberRespDto();


        return retData;
    }

    /**
     * D1-2查询员工身份人员列表[1253]
     * gen by moon at 2/20/2023, 2:36:37 PM
     */
    @Trace(operationName = "D1-2查询员工身份人员列表")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryStaffBeginMemberListRespDto queryStaffBeginMemberList(QueryStaffBeginMemberListReqDto reqDto) {


        List<OriginalRoleMember> listOriginalRoleMember_1 = new ArrayList<>();
        List<Userinfo> listUserinfo_3 = new ArrayList<>();
        List<OriginalRoleMemberInfo> listOriginalRoleMemberInfo_1 = new ArrayList<>();
        List<OriginalRoleMember> listOriginalRoleMember_3 = new ArrayList<>();
        if ((reqDto != null && reqDto.getIdCardName() != null)) {
            //if(D1-2查询员工身份人员列表.真实姓名 值不等于空 )  1398

            List<Userinfo> listUserinfo = new ArrayList<>();
            QueryUserInfoListReq queryUserInfoListReq = new QueryUserInfoListReq();
            if (reqDto != null) {
                queryUserInfoListReq.setIdCardName(reqDto.getIdCardName());//SimpleFieldAssign//sourceId:28910_1_1399
            }

            /*1-2-02查询个人资料列表（真实姓名搜索）[1178]   */

            listUserinfo = mUserinfoService.queryUserInfoList(queryUserInfoListReq);


            List<OriginalRoleMember> listOriginalRoleMember = new ArrayList<>();
            if (listUserinfo != null && !CollectionUtil.isEmpty(listUserinfo) && listUserinfo.size() > 0) {
                BatchQueryStaffBeginMemberListReq batchQueryStaffBeginMemberListReq = new BatchQueryStaffBeginMemberListReq();
                batchQueryStaffBeginMemberListReq.setStaffBeginMemberList(listUserinfo.stream().map(item -> item.getUserId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:29171_1_1400
                batchQueryStaffBeginMemberListReq.setRoleCode("STAFF");//CUSTOM_CONVENTION//sourceId:51540_1_1400
                if (reqDto != null) {
                    batchQueryStaffBeginMemberListReq.setIsInvalid(reqDto.getIsInvalid());//SimpleFieldAssign//sourceId:29181_1_1400
                    batchQueryStaffBeginMemberListReq.setSource(reqDto.getSource());//SimpleFieldAssign//sourceId:29176_1_1400
                    batchQueryStaffBeginMemberListReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:29196_1_1400
                }

                /*1-2-09批量查询员工身份人员列表[1259]   */
                Assert.isNull(batchQueryStaffBeginMemberListReq.getRoleCode(), "D1-2查询员工身份人员列表-1-2-09批量查询员工身份人员列表-身份角色编码不能为空", false);
                listOriginalRoleMember = mOriginalRoleMemberService.batchQueryStaffBeginMemberList(batchQueryStaffBeginMemberListReq);


                listOriginalRoleMember_1 = listOriginalRoleMember;
            }
            List<Userinfo> listUserinfo_2 = new ArrayList<>();
            if (listOriginalRoleMember != null && !CollectionUtil.isEmpty(listOriginalRoleMember) && listOriginalRoleMember.size() > 0) {
                BatchQueryUserinfoListReq batchQueryUserinfoListReq = new BatchQueryUserinfoListReq();
                batchQueryUserinfoListReq.setUserList(listOriginalRoleMember.stream().map(item -> item.getUserId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:28940_1_1401

                /*1-2-02批量查询个人资料列表[52]   */

                listUserinfo_2 = mUserinfoService.batchQueryUserinfoList(batchQueryUserinfoListReq);


                listUserinfo_3 = listUserinfo_2;
            }
            List<OriginalRoleMemberInfo> listOriginalRoleMemberInfo = new ArrayList<>();
            if (listOriginalRoleMember != null && !CollectionUtil.isEmpty(listOriginalRoleMember) && listOriginalRoleMember.size() > 0) {
                BatchQueryBeginMembInfoListReq batchQueryBeginMembInfoListReq = new BatchQueryBeginMembInfoListReq();
                batchQueryBeginMembInfoListReq.setBeginMembInfoList(listOriginalRoleMember.stream().map(item -> item.getOriginalRoleMemberId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:28946_1_1402

                /*1-2-10批量查询身份人员资料列表[1014]   */

                listOriginalRoleMemberInfo = mOriginalRoleMemberInfoService.batchQueryBeginMembInfoList(batchQueryBeginMembInfoListReq);


                listOriginalRoleMemberInfo_1 = listOriginalRoleMemberInfo;
            }
//processBranchName:正常结束 ,processBranchId:1403

        } else {
            //else  1404

            List<OriginalRoleMember> listOriginalRoleMember_2 = new ArrayList<>();
            QueryBeginMemberListReq queryBeginMemberListReq = new QueryBeginMemberListReq();
            queryBeginMemberListReq.setRoleCode("STAFF");//CUSTOM_CONVENTION//sourceId:29219_1_1405
            if (reqDto != null) {
                queryBeginMemberListReq.setSource(reqDto.getSource());//SimpleFieldAssign//sourceId:29209_1_1405
                queryBeginMemberListReq.setIsInvalid(reqDto.getIsInvalid());//SimpleFieldAssign//sourceId:29227_1_1405
                queryBeginMemberListReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:29213_1_1405
            }

            /*1-2-09查询身份人员列表（非搜索）[80]   */
            Assert.isNull(queryBeginMemberListReq.getRoleCode(), "D1-2查询员工身份人员列表-1-2-09查询身份人员列表（非搜索）-身份角色编码不能为空", false);
            listOriginalRoleMember_2 = mOriginalRoleMemberService.queryBeginMemberList(queryBeginMemberListReq);


            listOriginalRoleMember_3 = listOriginalRoleMember_2;
            List<Userinfo> listUserinfo_4 = new ArrayList<>();
            if (listOriginalRoleMember_2 != null && !CollectionUtil.isEmpty(listOriginalRoleMember_2) && listOriginalRoleMember_2.size() > 0) {
                BatchQueryUserinfoListReq batchQueryUserinfoListReq_1 = new BatchQueryUserinfoListReq();
                batchQueryUserinfoListReq_1.setUserList(listOriginalRoleMember_2.stream().map(item -> item.getUserId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:28940_1_1406

                /*1-2-02批量查询个人资料列表[52]   */

                listUserinfo_4 = mUserinfoService.batchQueryUserinfoList(batchQueryUserinfoListReq_1);


                listUserinfo_3 = listUserinfo_4;
            }
            List<OriginalRoleMemberInfo> listOriginalRoleMemberInfo_2 = new ArrayList<>();
            if (listOriginalRoleMember_2 != null && !CollectionUtil.isEmpty(listOriginalRoleMember_2) && listOriginalRoleMember_2.size() > 0) {
                BatchQueryBeginMembInfoListReq batchQueryBeginMembInfoListReq_1 = new BatchQueryBeginMembInfoListReq();
                batchQueryBeginMembInfoListReq_1.setBeginMembInfoList(listOriginalRoleMember_2.stream().map(item -> item.getOriginalRoleMemberId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:28946_1_1407

                /*1-2-10批量查询身份人员资料列表[1014]   */

                listOriginalRoleMemberInfo_2 = mOriginalRoleMemberInfoService.batchQueryBeginMembInfoList(batchQueryBeginMembInfoListReq_1);


                listOriginalRoleMemberInfo_1 = listOriginalRoleMemberInfo_2;
            }
//processBranchName:正常结束 ,processBranchId:1409

        }
        QueryStaffBeginMemberListRespDto retData = new QueryStaffBeginMemberListRespDto();
        //数据集融合  MoreListToOneSource
        if (listOriginalRoleMember_1 != null && !CollectionUtil.isEmpty(listOriginalRoleMember_1) && !CollectionUtil.isEmpty(listOriginalRoleMember_1)) {
            for (OriginalRoleMember originalRoleMember : listOriginalRoleMember_1) {
                BeginMemberDto retElm = new BeginMemberDto();
                retElm.setOriginalRoleMemberId(originalRoleMember.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:35342_2
                retElm.setUserId(originalRoleMember.getUserId());//SimpleFieldAssign//sourceId:35343_2
                retElm.setFirstLetter(originalRoleMember.getFirstLetter());//SimpleFieldAssign//sourceId:35349_2
                retElm.setIsInvalid(originalRoleMember.getIsInvalid());//SimpleFieldAssign//sourceId:35350_2
                retData.getBeginMemberList().add(retElm);
                if (listUserinfo_3 != null && !CollectionUtil.isEmpty(listUserinfo_3)) {
                    for (Userinfo userinfo : listUserinfo_3) {
                        if (userinfo.getUserId().equals(originalRoleMember.getUserId())) {
                            retElm.setUserFace(userinfo.getUserFace());//SimpleFieldAssign//sourceId:35347_2
                            retElm.setIdCardName(userinfo.getIdCardName());//SimpleFieldAssign//sourceId:35344_2
                            retElm.setNickName(userinfo.getNickName());//SimpleFieldAssign//sourceId:35346_2
                        }
                    }
                }

                if (listOriginalRoleMemberInfo_1 != null && !CollectionUtil.isEmpty(listOriginalRoleMemberInfo_1)) {
                    for (OriginalRoleMemberInfo originalRoleMemberInfo : listOriginalRoleMemberInfo_1) {
                        if (originalRoleMemberInfo.getOriginalRoleMemberId().equals(originalRoleMember.getOriginalRoleMemberId())) {
                            retElm.setRoleMemberCode(originalRoleMemberInfo.getRoleMemberCode());//SimpleFieldAssign//sourceId:35345_2
                            retElm.setPositionIdName(originalRoleMemberInfo.getPositionIdName());//SimpleFieldAssign//sourceId:35348_2
                        }
                    }
                }

            }
        }
//数据集融合  MoreListToOneSource
        if (listOriginalRoleMember_3 != null && !CollectionUtil.isEmpty(listOriginalRoleMember_3) && !CollectionUtil.isEmpty(listOriginalRoleMember_3)) {
            for (OriginalRoleMember originalRoleMember : listOriginalRoleMember_3) {
                BeginMemberDto retElm = new BeginMemberDto();
                retElm.setOriginalRoleMemberId(originalRoleMember.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:35342_2
                retElm.setUserId(originalRoleMember.getUserId());//SimpleFieldAssign//sourceId:35343_2
                retElm.setFirstLetter(originalRoleMember.getFirstLetter());//SimpleFieldAssign//sourceId:35349_2
                retElm.setIsInvalid(originalRoleMember.getIsInvalid());//SimpleFieldAssign//sourceId:35350_2
                retData.getBeginMemberList().add(retElm);
                if (listUserinfo_3 != null && !CollectionUtil.isEmpty(listUserinfo_3)) {
                    for (Userinfo userinfo : listUserinfo_3) {
                        if (userinfo.getUserId().equals(originalRoleMember.getUserId())) {
                            retElm.setUserFace(userinfo.getUserFace());//SimpleFieldAssign//sourceId:35347_2
                            retElm.setIdCardName(userinfo.getIdCardName());//SimpleFieldAssign//sourceId:35344_2
                            retElm.setNickName(userinfo.getNickName());//SimpleFieldAssign//sourceId:35346_2
                        }
                    }
                }

                if (listOriginalRoleMemberInfo_1 != null && !CollectionUtil.isEmpty(listOriginalRoleMemberInfo_1)) {
                    for (OriginalRoleMemberInfo originalRoleMemberInfo : listOriginalRoleMemberInfo_1) {
                        if (originalRoleMemberInfo.getOriginalRoleMemberId().equals(originalRoleMember.getOriginalRoleMemberId())) {
                            retElm.setRoleMemberCode(originalRoleMemberInfo.getRoleMemberCode());//SimpleFieldAssign//sourceId:35345_2
                            retElm.setPositionIdName(originalRoleMemberInfo.getPositionIdName());//SimpleFieldAssign//sourceId:35348_2
                        }
                    }
                }

            }
        }//sourceId:63325_1


        return retData;
    }

    /**
     * D1-2查询角色人员详情[1171]
     * gen by moon at 10/1/2022, 11:59:52 PM
     */
    @Trace(operationName = "D1-2查询角色人员详情")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryRoleRelDetailRespDto queryRoleRelDetail(QueryRoleRelDetailReqDto reqDto) {


        RoleMember roleMember_1 = null;
        Users users_1 = null;
        Userinfo userinfo_1 = null;
        OriginalRoleMemberInfo originalRoleMemberInfo_1 = null;
        SceneRole sceneRole_1 = null;
//步骤0: 1-2-13查询角色人员详情 - queryRoleRelDetail
        RoleMember roleMember = null;
        QueryRoleRelDetailReq queryRoleRelDetailReq = new QueryRoleRelDetailReq();
        if (reqDto != null) {
            queryRoleRelDetailReq.setRoleMemberId(reqDto.getRoleMemberId());//SimpleFieldAssign//sourceId:25584_1
        }

        /*1-2-13查询角色人员详情[335]   */
        Assert.isNull(queryRoleRelDetailReq.getRoleMemberId(), "D1-2查询角色人员详情-1-2-13查询角色人员详情-角色人员ID不能为空", false);
        roleMember = mRoleMemberService.queryRoleRelDetail(queryRoleRelDetailReq);


        roleMember_1 = roleMember;

//步骤1: 1-2-01查询个人账号详情 - queryUserDetail
        Users users = null;
        QueryUserDetailReq queryUserDetailReq = new QueryUserDetailReq();
        if (reqDto != null) {
            queryUserDetailReq.setUserId(reqDto.getUserId());//SimpleFieldAssign//sourceId:29334_1
        }

        /*1-2-01查询个人账号详情[286]   */
        Assert.isNull(queryUserDetailReq.getUserId(), "D1-2查询角色人员详情-1-2-01查询个人账号详情-个人账号不能为空", false);
        users = mUsersService.queryUserDetail(queryUserDetailReq);


        users_1 = users;

//步骤2: 1-2-02查询个人资料详情 - queryUserinfoDetail
        Userinfo userinfo = null;
        QueryUserinfoDetailReq queryUserinfoDetailReq = new QueryUserinfoDetailReq();
        if (reqDto != null) {
            queryUserinfoDetailReq.setUserId(reqDto.getUserId());//SimpleFieldAssign//sourceId:29331_1
        }

        /*1-2-02查询个人资料详情[155]   */
        Assert.isNull(queryUserinfoDetailReq.getUserId(), "D1-2查询角色人员详情-1-2-02查询个人资料详情-账号不能为空", false);
        userinfo = mUserinfoService.queryUserinfoDetail(queryUserinfoDetailReq);


        userinfo_1 = userinfo;

//步骤3: 1-2-10查询身份人员资料详情 - queryBeginMembInfoDetail
        OriginalRoleMemberInfo originalRoleMemberInfo = null;
        QueryBeginMembInfoDetailReq queryBeginMembInfoDetailReq = new QueryBeginMembInfoDetailReq();
        if (reqDto != null) {
            queryBeginMembInfoDetailReq.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:29394_1
        }

        /*1-2-10查询身份人员资料详情[116]   */
        Assert.isNull(queryBeginMembInfoDetailReq.getOriginalRoleMemberId(), "D1-2查询角色人员详情-1-2-10查询身份人员资料详情-身份人员ID不能为空", false);
        originalRoleMemberInfo = mOriginalRoleMemberInfoService.queryBeginMembInfoDetail(queryBeginMembInfoDetailReq);


        originalRoleMemberInfo_1 = originalRoleMemberInfo;

//步骤4: 1-2-08查询角色详情 - queryRoleDetail
        SceneRole sceneRole = null;
        QueryRoleDetailReq queryRoleDetailReq = new QueryRoleDetailReq();
        if (reqDto != null) {
            queryRoleDetailReq.setRoleId(reqDto.getRoleId());//SimpleFieldAssign//sourceId:29412_1
        }

        /*1-2-08查询角色详情[170]   */
        Assert.isNull(queryRoleDetailReq.getRoleId(), "D1-2查询角色人员详情-1-2-08查询角色详情-角色ID不能为空", false);
        sceneRole = mSceneRoleService.queryRoleDetail(queryRoleDetailReq);


        sceneRole_1 = sceneRole;

        QueryRoleRelDetailRespDto retData = new QueryRoleRelDetailRespDto();
        if (roleMember_1 != null) {
            retData.setRoleMemberId(roleMember_1.getRoleMemberId());//SimpleFieldAssign//sourceId:25626_1
            retData.setOriginalRoleMemberId(roleMember_1.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:25627_1
            retData.setUserId(roleMember_1.getUserId());//SimpleFieldAssign//sourceId:25628_1
            retData.setRoleId(roleMember_1.getRoleId());//SimpleFieldAssign//sourceId:25629_1
            retData.setRoleCode(roleMember_1.getRoleCode());//SimpleFieldAssign//sourceId:25630_1
            retData.setFirstLetter(roleMember_1.getFirstLetter());//SimpleFieldAssign//sourceId:25631_1
            retData.setSubjectLifeCycle(roleMember_1.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:25632_1
            retData.setRelationshipValid(roleMember_1.getRelationshipValid());//SimpleFieldAssign//sourceId:25633_1
            retData.setStatus(roleMember_1.getStatus());//SimpleFieldAssign//sourceId:25634_1
            retData.setInvalidReason(roleMember_1.getInvalidReason());//SimpleFieldAssign//sourceId:25635_1
            retData.setInvalidTime(roleMember_1.getInvalidTime());//SimpleFieldAssign//sourceId:25636_1
            retData.setIsArchive(roleMember_1.getIsArchive());//SimpleFieldAssign//sourceId:25637_1
            retData.setOperationInductionId(roleMember_1.getOperationInductionId());//SimpleFieldAssign//sourceId:25638_1
            retData.setCreateInductionId(roleMember_1.getCreateInductionId());//SimpleFieldAssign//sourceId:25639_1
            retData.setReleaseInductionId(roleMember_1.getReleaseInductionId());//SimpleFieldAssign//sourceId:25640_1
            retData.setArchiveInductionId(roleMember_1.getArchiveInductionId());//SimpleFieldAssign//sourceId:25641_1
            retData.setOperateTime(roleMember_1.getOperateTime());//SimpleFieldAssign//sourceId:25642_1
            retData.setCreateTime(roleMember_1.getCreateTime());//SimpleFieldAssign//sourceId:25643_1
            retData.setReleaseTime(roleMember_1.getReleaseTime());//SimpleFieldAssign//sourceId:25644_1
            retData.setArchiveTime(roleMember_1.getArchiveTime());//SimpleFieldAssign//sourceId:25645_1
            retData.setSpaceId(roleMember_1.getSpaceId());//SimpleFieldAssign//sourceId:25646_1
            retData.setAppId(roleMember_1.getAppId());//SimpleFieldAssign//sourceId:25647_1
        }
        if (users_1 != null) {
            retData.setUserName(users_1.getUserName());//SimpleFieldAssign//sourceId:29453_1
            retData.setEmail(users_1.getEmail());//SimpleFieldAssign//sourceId:29454_1
            retData.setPassByEmail(users_1.getPassByEmail());//SimpleFieldAssign//sourceId:29455_1
            retData.setPhone(users_1.getPhone());//SimpleFieldAssign//sourceId:29456_1
            retData.setPassByPhone(users_1.getPassByPhone());//SimpleFieldAssign//sourceId:29457_1
            retData.setIsUserInfoDone(users_1.getIsUserInfoDone());//SimpleFieldAssign//sourceId:29458_1
            retData.setRegTime(users_1.getRegTime());//SimpleFieldAssign//sourceId:29459_1
            retData.setLastLoginTime(users_1.getLastLoginTime());//SimpleFieldAssign//sourceId:29460_1
            retData.setLastLoginIp(users_1.getLastLoginIp());//SimpleFieldAssign//sourceId:29461_1
            retData.setSourceCode(users_1.getSourceCode());//SimpleFieldAssign//sourceId:29462_1
            retData.setInviteUserId(users_1.getInviteUserId());//SimpleFieldAssign//sourceId:29463_1
        }
        if (userinfo_1 != null) {
            retData.setIdCardName(userinfo_1.getIdCardName());//SimpleFieldAssign//sourceId:29467_1
            retData.setNickName(userinfo_1.getNickName());//SimpleFieldAssign//sourceId:29468_1
            retData.setUserFace(userinfo_1.getUserFace());//SimpleFieldAssign//sourceId:29469_1
            retData.setUserIntro(userinfo_1.getUserIntro());//SimpleFieldAssign//sourceId:29470_1
            retData.setSex(userinfo_1.getSex());//SimpleFieldAssign//sourceId:29471_1
            retData.setBirthday(userinfo_1.getBirthday());//SimpleFieldAssign//sourceId:29472_1
            retData.setCity(userinfo_1.getCity());//SimpleFieldAssign//sourceId:29473_1
        }
        if (originalRoleMemberInfo_1 != null) {
            retData.setRoleMemberCode(originalRoleMemberInfo_1.getRoleMemberCode());//SimpleFieldAssign//sourceId:29474_1
            retData.setPositionIdName(originalRoleMemberInfo_1.getPositionIdName());//SimpleFieldAssign//sourceId:29475_1
            retData.setInductionTypeDictionaryId(originalRoleMemberInfo_1.getInductionTypeDictionaryId());//SimpleFieldAssign//sourceId:29476_1
            retData.setInductionStateDictionaryId(originalRoleMemberInfo_1.getInductionStateDictionaryId());//SimpleFieldAssign//sourceId:29477_1
            retData.setIsPtJob(originalRoleMemberInfo_1.getIsPtJob());//SimpleFieldAssign//sourceId:45913_1
        }
        if (sceneRole_1 != null) {
            retData.setRoleName(sceneRole_1.getRoleName());//SimpleFieldAssign//sourceId:29479_1
            retData.setRoleLogo(sceneRole_1.getRoleLogo());//SimpleFieldAssign//sourceId:29480_1
        }


        return retData;
    }

    /**
     * D1-2查询角色人员列表[1134]
     * gen by moon at 10/23/2022, 12:02:36 AM
     */
    @Trace(operationName = "D1-2查询角色人员列表")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryRoleRelListRespDto queryRoleRelList(QueryRoleRelListReqDto reqDto) {


        List<RoleMember> listRoleMember_1 = new ArrayList<>();
        List<SceneRole> listSceneRole_1 = new ArrayList<>();
        List<OriginalRoleMemberInfo> listOriginalRoleMemberInfo_1 = new ArrayList<>();
        List<Userinfo> listUserinfo_1 = new ArrayList<>();
//步骤0: 1-2-13查询角色人员列表 - queryRoleRelList
        List<RoleMember> listRoleMember = new ArrayList<>();
        QueryRoleRelListReq queryRoleRelListReq = new QueryRoleRelListReq();
        if (reqDto != null) {
            queryRoleRelListReq.setRoleCode(reqDto.getRoleCode());//SimpleFieldAssign//sourceId:23415_1
            queryRoleRelListReq.setRelationshipValid(reqDto.getRelationshipValid());//SimpleFieldAssign//sourceId:50601_1
            queryRoleRelListReq.setIsArchive(reqDto.getIsArchive());//SimpleFieldAssign//sourceId:23432_1
            queryRoleRelListReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:23430_1
            queryRoleRelListReq.setRoleId(reqDto.getRoleId());//SimpleFieldAssign//sourceId:51519_1
        }

        /*1-2-13查询角色人员列表[334] 根据出参的身份人员ID、个人账号ID，作为下面入参  */

        listRoleMember = mRoleMemberService.queryRoleRelList(queryRoleRelListReq);


        listRoleMember_1 = listRoleMember;

//步骤1: 1-2-08批量查询角色列表 - batchQueryRoleList
        List<SceneRole> listSceneRole = new ArrayList<>();
        if (listRoleMember != null && !CollectionUtil.isEmpty(listRoleMember) && listRoleMember.size() > 0) {
            BatchQueryRoleListReq batchQueryRoleListReq = new BatchQueryRoleListReq();
            batchQueryRoleListReq.setRoleList(listRoleMember.stream().map(item -> item.getRoleId())
                    .collect(Collectors.toList()));/*list-to-strings*///sourceId:23464_1

            /*1-2-08批量查询角色列表[700]   */

            listSceneRole = mSceneRoleService.batchQueryRoleList(batchQueryRoleListReq);


            listSceneRole_1 = listSceneRole;
        }

//步骤2: 1-2-10批量查询身份人员资料列表 - batchQueryBeginMembInfoList
        List<OriginalRoleMemberInfo> listOriginalRoleMemberInfo = new ArrayList<>();
        if (listRoleMember != null && !CollectionUtil.isEmpty(listRoleMember) && listRoleMember.size() > 0) {
            BatchQueryBeginMembInfoListReq batchQueryBeginMembInfoListReq = new BatchQueryBeginMembInfoListReq();
            batchQueryBeginMembInfoListReq.setBeginMembInfoList(listRoleMember.stream().map(item -> item.getOriginalRoleMemberId())
                    .collect(Collectors.toList()));/*list-to-strings*///sourceId:23434_1

            /*1-2-10批量查询身份人员资料列表[1014] 接受上面身份人员ID作为入参，查出工号、职务展示信息  */

            listOriginalRoleMemberInfo = mOriginalRoleMemberInfoService.batchQueryBeginMembInfoList(batchQueryBeginMembInfoListReq);


            listOriginalRoleMemberInfo_1 = listOriginalRoleMemberInfo;
        }

//步骤3: 1-2-02批量查询个人资料列表 - batchQueryUserinfoList
        List<Userinfo> listUserinfo = new ArrayList<>();
        if (listRoleMember != null && !CollectionUtil.isEmpty(listRoleMember) && listRoleMember.size() > 0) {
            BatchQueryUserinfoListReq batchQueryUserinfoListReq = new BatchQueryUserinfoListReq();
            batchQueryUserinfoListReq.setUserList(listRoleMember.stream().map(item -> item.getUserId())
                    .collect(Collectors.toList()));/*list-to-strings*///sourceId:23435_1

            /*1-2-02批量查询个人资料列表[52] 接受上面个人账号ID作为入参，查出头像、真实姓名等  */

            listUserinfo = mUserinfoService.batchQueryUserinfoList(batchQueryUserinfoListReq);


            listUserinfo_1 = listUserinfo;
        }

        QueryRoleRelListRespDto retData = new QueryRoleRelListRespDto();
        //数据集融合  MoreListToOneSource
        if (listRoleMember_1 != null && !CollectionUtil.isEmpty(listRoleMember_1) && !CollectionUtil.isEmpty(listRoleMember_1)) {
            for (RoleMember roleMember : listRoleMember_1) {
                RoleRelDto retElm = new RoleRelDto();
                retElm.setRoleMemberId(roleMember.getRoleMemberId());//SimpleFieldAssign//sourceId:9194_2
                retElm.setOriginalRoleMemberId(roleMember.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:12585_2
                retElm.setUserId(roleMember.getUserId());//SimpleFieldAssign//sourceId:12586_2
                retElm.setSubjectLifeCycle(roleMember.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:12588_2
                retElm.setIsArchive(roleMember.getIsArchive());//SimpleFieldAssign//sourceId:12589_2
                retElm.setOperationInductionId(roleMember.getOperationInductionId());//SimpleFieldAssign//sourceId:12590_2
                retElm.setOperateTime(roleMember.getOperateTime());//SimpleFieldAssign//sourceId:12591_2
                retElm.setSpaceId(roleMember.getSpaceId());//SimpleFieldAssign//sourceId:12592_2
                retElm.setRelationshipValid(roleMember.getRelationshipValid());//SimpleFieldAssign//sourceId:26612_2
                retElm.setAppId(roleMember.getAppId());//SimpleFieldAssign//sourceId:12593_2
                retElm.setRoleId(roleMember.getRoleId());//SimpleFieldAssign//sourceId:12587_2
                retData.getRoleRelList().add(retElm);
                if (listSceneRole_1 != null && !CollectionUtil.isEmpty(listSceneRole_1)) {
                    for (SceneRole sceneRole : listSceneRole_1) {
                        if (sceneRole.getRoleId().equals(roleMember.getRoleId())) {
                            retElm.setRoleName(sceneRole.getRoleName());//SimpleFieldAssign//sourceId:12594_2
                            retElm.setRoleLogo(sceneRole.getRoleLogo());//SimpleFieldAssign//sourceId:12595_2
                        }
                    }
                }

                if (listOriginalRoleMemberInfo_1 != null && !CollectionUtil.isEmpty(listOriginalRoleMemberInfo_1)) {
                    for (OriginalRoleMemberInfo originalRoleMemberInfo : listOriginalRoleMemberInfo_1) {
                        if (originalRoleMemberInfo.getOriginalRoleMemberId().equals(roleMember.getOriginalRoleMemberId())) {
                            retElm.setPositionIdName(originalRoleMemberInfo.getPositionIdName());//SimpleFieldAssign//sourceId:12597_2
                            retElm.setRoleMemberCode(originalRoleMemberInfo.getRoleMemberCode());//SimpleFieldAssign//sourceId:12596_2
                            retElm.setRelaMemo(originalRoleMemberInfo.getRelaMemo());//SimpleFieldAssign//sourceId:12598_2
                        }
                    }
                }

                if (listUserinfo_1 != null && !CollectionUtil.isEmpty(listUserinfo_1)) {
                    for (Userinfo userinfo : listUserinfo_1) {
                        if (userinfo.getUserId().equals(roleMember.getUserId())) {
                            retElm.setUserFace(userinfo.getUserFace());//SimpleFieldAssign//sourceId:12599_2
                            retElm.setIdCardName(userinfo.getIdCardName());//SimpleFieldAssign//sourceId:12600_2
                            retElm.setNickName(userinfo.getNickName());//SimpleFieldAssign//sourceId:12601_2
                        }
                    }
                }

            }
        }//sourceId:23445_1


        return retData;
    }

    /**
     * D1-2新增角色人员[737]
     * gen by moon at 12/22/2022, 5:41:55 PM
     */
    @Trace(operationName = "D1-2新增角色人员")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AddRoleRelRespDto addRoleRel(AddRoleRelReqDto reqDto) {


        String string_1 = null;
//virtualUsage 1-2-13查询角色人员详情（查角色人员是否存在）  1030
        RoleMember roleMember = null;
        QueryRoleRelDetailReq queryRoleRelDetailReq = new QueryRoleRelDetailReq();
        queryRoleRelDetailReq.setIsArchive("FALSE");//sourceId:31925_1_1030
        if (reqDto != null) {
            queryRoleRelDetailReq.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:23985_1_1030
            queryRoleRelDetailReq.setRoleCode(reqDto.getRoleCode());//SimpleFieldAssign//sourceId:23986_1_1030
        }

    /*1-2-13查询角色人员详情（查角色人员是否存在）[335] 通过前端选择的员工身份人员ID入参判断 该员工是否已经是管理员；
返回有值就是返回前端报错“已经是角色成员，请选择其他人“。如果为空，执行下一步  */
        Assert.isNull(queryRoleRelDetailReq.getOriginalRoleMemberId(), "D1-2新增角色人员-1-2-13查询角色人员详情（查角色人员是否存在）-身份人员ID不能为空", false);
        Assert.isNull(queryRoleRelDetailReq.getRoleCode(), "D1-2新增角色人员-1-2-13查询角色人员详情（查角色人员是否存在）-角色标识不能为空", false);
        Assert.isNull(queryRoleRelDetailReq.getIsArchive(), "D1-2新增角色人员-1-2-13查询角色人员详情（查角色人员是否存在）-是否存档不能为空", false);
        roleMember = mRoleMemberService.queryRoleRelDetail(queryRoleRelDetailReq);


        if ((roleMember == null)) {
            //if(1-2-13查询角色人员详情（查角色人员是否存在）.出参 等于空 )  1159

            if ((reqDto != null && reqDto.getRoleCode() != null && reqDto.getRoleCode().equals("DEPT_ADMIN") || reqDto != null && reqDto.getRoleCode() != null && reqDto.getRoleCode().equals("ADMIN") || reqDto != null && reqDto.getRoleCode() != null && reqDto.getRoleCode().equals("ORG_ADMIN") || reqDto != null && reqDto.getRoleCode() != null && reqDto.getRoleCode().equals("DEPT_LEADER") || reqDto != null && reqDto.getRoleCode() != null && reqDto.getRoleCode().equals("INSPECTION_ROLE"))) {
                //if((D1-2新增角色人员.角色标识 等于 部门管理员 or D1-2新增角色人员.角色标识 等于 空间管理员 or D1-2新增角色人员.角色标识 等于 组织架构管理员 or D1-2新增角色人员.角色标识 等于 分管领导 or D1-2新增角色人员.角色标识 等于 视察角色))  24464

                List<InductionRecord> listInductionRecord = new ArrayList<>();
                QueryInductionRecordListReq queryInductionRecordListReq = new QueryInductionRecordListReq();
                queryInductionRecordListReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:501224_1_24465
                queryInductionRecordListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:501225_1_24465
                if (reqDto != null) {
                    queryInductionRecordListReq.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:501223_1_24465
                }

                /*1-3-13查询就职记录列表[166]   */
                Assert.isNull(queryInductionRecordListReq.getOriginalRoleMemberId(), "D1-2新增角色人员-1-3-13查询就职记录列表-身份人员ID不能为空", false);
                Assert.isNull(queryInductionRecordListReq.getSubjectLifeCycle(), "D1-2新增角色人员-1-3-13查询就职记录列表-主体生命周期不能为空", false);
                Assert.isNull(queryInductionRecordListReq.getSpaceId(), "D1-2新增角色人员-1-3-13查询就职记录列表-创建于空间ID不能为空", false);
                listInductionRecord = mInductionRecordService.queryInductionRecordList(queryInductionRecordListReq);


                if ((listInductionRecord != null && listInductionRecord != null && listInductionRecord.size() > 0)) {
                    //if(1-3-13查询就职记录列表（判断身份人员是否存在就职记录）.就职记录列表数据集条数 大于 0)  24466

                    String string = null;
                    RoleMember roleMember_2 = new RoleMember();
                    roleMember_2.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:23907_1_24467
                    roleMember_2.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:23908_1_24467
                    if (reqDto != null) {
                        roleMember_2.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:27255_1_24467
                        roleMember_2.setUserId(reqDto.getUserId());//SimpleFieldAssign//sourceId:54482_1_24467
                        roleMember_2.setRoleId(reqDto.getRoleId());//SimpleFieldAssign//sourceId:23901_1_24467
                        roleMember_2.setRoleCode(reqDto.getRoleCode());//SimpleFieldAssign//sourceId:23902_1_24467
                        roleMember_2.setFirstLetter(reqDto.getFirstLetter());//SimpleFieldAssign//sourceId:23903_1_24467
                        roleMember_2.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:23904_1_24467
                    }

                    /*1-2-13新增角色人员[331]   */
                    Assert.isNull(roleMember_2.getOriginalRoleMemberId(), "D1-2新增角色人员-1-2-13新增角色人员-身份人员ID不能为空", false);
                    Assert.isNull(roleMember_2.getUserId(), "D1-2新增角色人员-1-2-13新增角色人员-账号ID不能为空", false);
                    Assert.isNull(roleMember_2.getRoleId(), "D1-2新增角色人员-1-2-13新增角色人员-角色ID不能为空", false);
                    Assert.isNull(roleMember_2.getRoleCode(), "D1-2新增角色人员-1-2-13新增角色人员-角色标识不能为空", false);
                    Assert.isNull(roleMember_2.getFirstLetter(), "D1-2新增角色人员-1-2-13新增角色人员-备注首位字母不能为空", false);
                    Assert.isNull(roleMember_2.getSubjectLifeCycle(), "D1-2新增角色人员-1-2-13新增角色人员-主体生命周期不能为空", false);
                    Assert.isNull(roleMember_2.getSpaceId(), "D1-2新增角色人员-1-2-13新增角色人员-创建于空间ID不能为空", false);
                    Assert.isNull(roleMember_2.getAppId(), "D1-2新增角色人员-1-2-13新增角色人员-创建于联盟应用ID不能为空", false);
                    string = mRoleMemberService.addRoleRel(roleMember_2);


                    string_1 = string;
                } else {
                    //else  24472

//异常结束 24473
                    throw new BizException("10500161", "对不起！请将该员工添加到部门后，再设角色身份~", false);
                }
            } else {
                //else  24468

                String string_2 = null;
                RoleMember roleMember_3 = new RoleMember();
                roleMember_3.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:23907_1_24474
                roleMember_3.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:23908_1_24474
                if (reqDto != null) {
                    roleMember_3.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:27255_1_24474
                    roleMember_3.setUserId(reqDto.getUserId());//SimpleFieldAssign//sourceId:54482_1_24474
                    roleMember_3.setRoleId(reqDto.getRoleId());//SimpleFieldAssign//sourceId:23901_1_24474
                    roleMember_3.setRoleCode(reqDto.getRoleCode());//SimpleFieldAssign//sourceId:23902_1_24474
                    roleMember_3.setFirstLetter(reqDto.getFirstLetter());//SimpleFieldAssign//sourceId:23903_1_24474
                    roleMember_3.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:23904_1_24474
                }

                /*1-2-13新增角色人员[331]   */
                Assert.isNull(roleMember_3.getOriginalRoleMemberId(), "D1-2新增角色人员-1-2-13新增角色人员-身份人员ID不能为空", false);
                Assert.isNull(roleMember_3.getUserId(), "D1-2新增角色人员-1-2-13新增角色人员-账号ID不能为空", false);
                Assert.isNull(roleMember_3.getRoleId(), "D1-2新增角色人员-1-2-13新增角色人员-角色ID不能为空", false);
                Assert.isNull(roleMember_3.getRoleCode(), "D1-2新增角色人员-1-2-13新增角色人员-角色标识不能为空", false);
                Assert.isNull(roleMember_3.getFirstLetter(), "D1-2新增角色人员-1-2-13新增角色人员-备注首位字母不能为空", false);
                Assert.isNull(roleMember_3.getSubjectLifeCycle(), "D1-2新增角色人员-1-2-13新增角色人员-主体生命周期不能为空", false);
                Assert.isNull(roleMember_3.getSpaceId(), "D1-2新增角色人员-1-2-13新增角色人员-创建于空间ID不能为空", false);
                Assert.isNull(roleMember_3.getAppId(), "D1-2新增角色人员-1-2-13新增角色人员-创建于联盟应用ID不能为空", false);
                string_2 = mRoleMemberService.addRoleRel(roleMember_3);


                string_1 = string_2;
            }
//processBranchName:正常结束 ,processBranchId:1163

        } else {
            //else  1160

//异常结束 1161
            throw new BizException("C00116", "对不起！已存在~！", false);
        }
        AddRoleRelRespDto retData = new AddRoleRelRespDto();
        if (string_1 != null) {
            retData.setRoleMemberId(string_1);//SimpleFieldAssign//sourceId:47308_1
        }


        return retData;
    }

    /**
     * D1-2新增员工身份人员[978]
     * gen by moon at 11/26/2023, 2:26:47 PM
     */
    @Trace(operationName = "D1-2新增员工身份人员")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AddStaffBeginMemberRespDto addStaffBeginMember(AddStaffBeginMemberReqDto reqDto) {


        Users users_1 = null;
        String string_1 = null;
        String string_3 = null;
        String string_5 = null;
        SceneRole sceneRole_1 = null;
        String string_7 = null;
        String string_9 = null;
        String string_11 = null;
        Userinfo userinfo_3 = null;
//virtualUsage M-检测验证码是否有效（特殊方法）  586
        //ModelCode: checkCaptchaValid
        CheckCaptchaValidRespDto checkCaptchaValidRes = null;
        CheckCaptchaValidReqDto checkCaptchaValidReq = new CheckCaptchaValidReqDto();
        if (reqDto != null) {
            checkCaptchaValidReq.setVerificationCode(reqDto.getVerificationCode());//SimpleFieldAssign//sourceId:41303_1_586
        }

        /*M-检测验证码是否有效（特殊方法）[1421] 前端验证码字段有入参值，就执行此步；如果没有入参值，就跳转查询个人账号详情（查询手机号是否存在） 用于检测用户前端录入验证码是否有效 */

        checkCaptchaValidRes = nbMember.checkCaptchaValid(checkCaptchaValidReq);


//virtualUsage 1-2-01查询个人账号详情  587
        Users users = null;
        QueryUserDetailReq queryUserDetailReq = new QueryUserDetailReq();
        if (reqDto != null) {
            queryUserDetailReq.setPhone(reqDto.getPhone());//SimpleFieldAssign//sourceId:20706_1_587
        }

        /*1-2-01查询个人账号详情[286]  通过手机号进行账号查询，无就结束查询，执行下一步注册个人账号；如果有账号执行下一步查询；  */
        Assert.isNull(queryUserDetailReq.getPhone(), "D1-2新增员工身份人员-1-2-01查询个人账号详情-绑定手机不能为空", false);
        users = mUsersService.queryUserDetail(queryUserDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        users_1 = users;
//virtualUsage 1-3-12查询组织详情  5658
        Organization organization = null;
        QueryOrgDetailReq queryOrgDetailReq = new QueryOrgDetailReq();
        queryOrgDetailReq.setIsHighOrg("TRUE");//sourceId:20888_1_5658
        queryOrgDetailReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:20889_1_5658

        /*1-3-12查询组织详情[201] 查询空间唯一的最高组织ID，出参有无组织架构模式及是否开启编制计划模式；如果组织架构模式是宽松或严格就终止步骤；如果是无组织架构模式，执行下一步。  */
        Assert.isNull(queryOrgDetailReq.getIsHighOrg(), "D1-2新增员工身份人员-1-3-12查询组织详情-是否最高组织不能为空", false);
        organization = mOrganizationService.queryOrgDetail(queryOrgDetailReq)/*vcase invoke 本地 method 方法调用;*/;


//virtualUsage D2-3查询配置项匹配结果转答案(公共)  5657
        QueryItemMatchResultToAnswerDetailComRespDto queryItemMatchResultToAnswerDetailComRespDto = null;
        QueryItemMatchResultToAnswerDetailComReqDto queryItemMatchResultToAnswerDetailComReqDto = new QueryItemMatchResultToAnswerDetailComReqDto();
        queryItemMatchResultToAnswerDetailComReqDto.setConfItemCode("ORG_STRUCTURE_MODEL");//CUSTOM_CONVENTION//sourceId:104982_1_5657
        queryItemMatchResultToAnswerDetailComReqDto.setResultAspObjType("TENANT_SPACE");//sourceId:104983_1_5657
        queryItemMatchResultToAnswerDetailComReqDto.setResultAspObjId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:104984_1_5657
        queryItemMatchResultToAnswerDetailComReqDto.setIsInitialScheme("TRUE");//sourceId:308358_1_5657
        queryItemMatchResultToAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:308359_1_5657

        /*D2-3查询配置项匹配结果转答案(公共)[3094]   */
        Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto.getConfItemCode(), "D1-2新增员工身份人员-D2-3查询配置项匹配结果转答案(公共)-配置项标识不能为空", false);
        Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto.getResultAspObjType(), "D1-2新增员工身份人员-D2-3查询配置项匹配结果转答案(公共)-开通对象类型编码不能为空", false);
        Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto.getResultAspObjId(), "D1-2新增员工身份人员-D2-3查询配置项匹配结果转答案(公共)-开通对象ID不能为空", false);
        Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto.getIsInitialScheme(), "D1-2新增员工身份人员-D2-3查询配置项匹配结果转答案(公共)-是否初始方案答案不能为空", false);
        Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto.getIsPlatData(), "D1-2新增员工身份人员-D2-3查询配置项匹配结果转答案(公共)-是否标准答案不能为空", false);
        queryItemMatchResultToAnswerDetailComRespDto = confSchemeService.queryItemMatchResultToAnswerDetailCom(queryItemMatchResultToAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


        if ((queryItemMatchResultToAnswerDetailComRespDto != null && queryItemMatchResultToAnswerDetailComRespDto.getOrgStructureModel() != null && queryItemMatchResultToAnswerDetailComRespDto.getOrgStructureModel().equals("NO_ORG") && users == null && reqDto != null && reqDto.getVerificationCode() == null) || (queryItemMatchResultToAnswerDetailComRespDto != null && queryItemMatchResultToAnswerDetailComRespDto.getOrgStructureModel() != null && queryItemMatchResultToAnswerDetailComRespDto.getOrgStructureModel().equals("NO_ORG") && users == null && checkCaptchaValidRes != null && checkCaptchaValidRes.getIsInvalid() != null && checkCaptchaValidRes.getIsInvalid().equals("TRUE"))) {
            //if((D2-3查询配置项匹配结果转答案(公共).空间组织架构模式 等于 无组织架构 and 1-2-01查询个人账号详情.出参 值等于空  and D1-2新增员工身份人员.验证码 值等于空 ) or (D2-3查询配置项匹配结果转答案(公共).空间组织架构模式 等于 无组织架构 and 1-2-01查询个人账号详情.出参 值等于空  and M-检测验证码是否有效（特殊方法）.是否有效 等于 是))  590

            JudgeAddPerfectStaffUsableComRespDto judgeAddPerfectStaffUsableComRespDto = null;
            JudgeAddPerfectStaffUsableComReqDto judgeAddPerfectStaffUsableComReqDto = new JudgeAddPerfectStaffUsableComReqDto();
            judgeAddPerfectStaffUsableComReqDto.setRoleCode("ORG_ADMIN");//CUSTOM_CONVENTION//sourceId:213934_1_54620
            judgeAddPerfectStaffUsableComReqDto.setPrivacyCode("MGT_ORG_POWER");//CUSTOM_CONVENTION//sourceId:213935_1_54620
            if (reqDto != null) {
                judgeAddPerfectStaffUsableComReqDto.setUserName(reqDto.getUserName());//SimpleFieldAssign//sourceId:213927_1_54620
                judgeAddPerfectStaffUsableComReqDto.setRoleMemberCode(reqDto.getRoleMemberCode());//SimpleFieldAssign//sourceId:213923_1_54620
                judgeAddPerfectStaffUsableComReqDto.setPhone(reqDto.getPhone());//SimpleFieldAssign//sourceId:213924_1_54620
            }

            /*D1判断注册完善员工操作可用(公共)[4015]   */
            Assert.isNull(judgeAddPerfectStaffUsableComReqDto.getRoleMemberCode(), "D1-2新增员工身份人员-D1判断注册完善员工操作可用(公共)-身份人员编号不能为空", false);
            Assert.isNull(judgeAddPerfectStaffUsableComReqDto.getRoleCode(), "D1-2新增员工身份人员-D1判断注册完善员工操作可用(公共)-角色标识不能为空", false);
            Assert.isNull(judgeAddPerfectStaffUsableComReqDto.getPrivacyCode(), "D1-2新增员工身份人员-D1判断注册完善员工操作可用(公共)-权限标识不能为空", false);
            judgeAddPerfectStaffUsableComRespDto = judgeAddPerfectStaffUsableCom(judgeAddPerfectStaffUsableComReqDto)/*vcase invoke 同服务,同domain*/;
            Assert.isTrue(judgeAddPerfectStaffUsableComRespDto == null || judgeAddPerfectStaffUsableComRespDto.getOutputNum() == null, "找不到数据，系统异常", false);


            String string = null;
            Users users_2 = new Users();
            users_2.setPassByEmail("FALSE");//sourceId:20717_1_3930
            users_2.setDevName(CommonFunctionHelper.getEquipMent());//GET_EQUIPMENT//sourceId:45505_1_3930
            users_2.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:20731_1_3930
            users_2.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:20732_1_3930
            if (reqDto != null) {
                users_2.setPassword(reqDto.getPassword());//SimpleFieldAssign//sourceId:43900_1_3930
                users_2.setUserName(reqDto.getUserName());//SimpleFieldAssign//sourceId:45501_1_3930
                users_2.setPhone(reqDto.getPhone());//SimpleFieldAssign//sourceId:20718_1_3930
                users_2.setPassByPhone(reqDto.getPassByPhone());//SimpleFieldAssign//sourceId:20719_1_3930
                users_2.setIsPasswordExit(reqDto.getIsPasswordExit());//SimpleFieldAssign//sourceId:45502_1_3930
                users_2.setEmail(reqDto.getEmail());//SimpleFieldAssign//sourceId:45503_1_3930
                users_2.setIsUserInfoDone(reqDto.getIsUserInfoDone());//SimpleFieldAssign//sourceId:45504_1_3930
                users_2.setSenceId(reqDto.getSenceId());//SimpleFieldAssign//sourceId:45507_1_3930
            }

            /*1-2-01新增个人账号[45] 前面判断没有个人账号，执行此步注册账号  */
            Assert.isNull(users_2.getPassByEmail(), "D1-2新增员工身份人员-1-2-01新增个人账号-邮箱激活状态不能为空", false);
            Assert.isNull(users_2.getPassword(), "D1-2新增员工身份人员-1-2-01新增个人账号-密码不能为空", false);
            Assert.isNull(users_2.getPhone(), "D1-2新增员工身份人员-1-2-01新增个人账号-绑定手机不能为空", false);
            Assert.isNull(users_2.getPassByPhone(), "D1-2新增员工身份人员-1-2-01新增个人账号-手机激活状态不能为空", false);
            Assert.isNull(users_2.getIsPasswordExit(), "D1-2新增员工身份人员-1-2-01新增个人账号-密码是否为空不能为空", false);
            Assert.isNull(users_2.getIsUserInfoDone(), "D1-2新增员工身份人员-1-2-01新增个人账号-个人资料是否完善不能为空", false);
            Assert.isNull(users_2.getSenceId(), "D1-2新增员工身份人员-1-2-01新增个人账号-归属于场景ID不能为空", false);
            Assert.isNull(users_2.getSpaceId(), "D1-2新增员工身份人员-1-2-01新增个人账号-创建于空间ID不能为空", false);
            Assert.isNull(users_2.getAppId(), "D1-2新增员工身份人员-1-2-01新增个人账号-创建于联盟应用ID不能为空", false);
            string = mUsersService.addUser(users_2)/*vcase invoke 本地 method 方法调用;*/;


            string_1 = string;
            String string_2 = null;
            if (string != null) {
                Userinfo userinfo = new Userinfo();
                userinfo.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:20743_1_3931
                userinfo.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:20744_1_3931
                if (string != null) {
                    userinfo.setUserId(string);//SimpleFieldAssign//sourceId:20735_1_3931
                }
                if (reqDto != null) {
                    userinfo.setIdCardName(reqDto.getIdCardName());//SimpleFieldAssign//sourceId:20736_1_3931
                    userinfo.setFirstLetter(CommonFunctionHelper.firstChar(reqDto.getIdCardName()));//FIRST_CHAR //todo 字段备注首位字母来源为空,请设置!!;//sourceId:56814_1_3931
                    userinfo.setUserFace(reqDto.getUserFace());//SimpleFieldAssign//sourceId:20738_1_3931
                }

                /*1-2-02新增个人资料[49] 根据上一步入参的个人账号ID，生成个人资料。  */
                Assert.isNull(userinfo.getUserId(), "D1-2新增员工身份人员-1-2-02新增个人资料-账号不能为空", false);
                Assert.isNull(userinfo.getIdCardName(), "D1-2新增员工身份人员-1-2-02新增个人资料-真实姓名不能为空", false);
                Assert.isNull(userinfo.getFirstLetter(), "D1-2新增员工身份人员-1-2-02新增个人资料-备注首位字母不能为空", false);
                Assert.isNull(userinfo.getUserFace(), "D1-2新增员工身份人员-1-2-02新增个人资料-真实头像不能为空", false);
                Assert.isNull(userinfo.getSpaceId(), "D1-2新增员工身份人员-1-2-02新增个人资料-创建于空间ID不能为空", false);
                Assert.isNull(userinfo.getAppId(), "D1-2新增员工身份人员-1-2-02新增个人资料-归属应用ID不能为空", false);
                string_2 = mUserinfoService.addUserinfo(userinfo)/*vcase invoke 本地 method 方法调用;*/;


                string_3 = string_2;
            }
            String string_4 = null;
            if (string != null) {
                SpaceMember spaceMember = new SpaceMember();
                spaceMember.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:20748_1_3932
                spaceMember.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:20749_1_3932
                if (string != null) {
                    spaceMember.setUserId(string);//SimpleFieldAssign//sourceId:20747_1_3932
                }

                /*1-2-05新增空间成员关系[61] 上一步注册个人账号成功出参后，本步生成成员ID  */
                Assert.isNull(spaceMember.getUserId(), "D1-2新增员工身份人员-1-2-05新增空间成员关系-成员个人账号不能为空", false);
                Assert.isNull(spaceMember.getSpaceId(), "D1-2新增员工身份人员-1-2-05新增空间成员关系-创建于空间ID不能为空", false);
                Assert.isNull(spaceMember.getAppId(), "D1-2新增员工身份人员-1-2-05新增空间成员关系-创建于联盟应用ID不能为空", false);
                string_4 = mSpaceMemberService.addMember(spaceMember)/*vcase invoke 本地 method 方法调用;*/;


                string_5 = string_4;
            }
            SceneRole sceneRole = null;
            QueryRoleDetailReq queryRoleDetailReq = new QueryRoleDetailReq();
            queryRoleDetailReq.setRoleCode("STAFF");//CUSTOM_CONVENTION//sourceId:23851_1_3933
            queryRoleDetailReq.setIsIdentity("TRUE");//sourceId:23852_1_3933
            queryRoleDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:23853_1_3933

            /*1-2-08查询角色详情[170] 查询员工原始角色STAFF，出参角色ID  */
            Assert.isNull(queryRoleDetailReq.getRoleCode(), "D1-2新增员工身份人员-1-2-08查询角色详情-角色标识不能为空", false);
            Assert.isNull(queryRoleDetailReq.getIsIdentity(), "D1-2新增员工身份人员-1-2-08查询角色详情-是否身份角色不能为空", false);
            Assert.isNull(queryRoleDetailReq.getSubjectLifeCycle(), "D1-2新增员工身份人员-1-2-08查询角色详情-主体生命周期不能为空", false);
            sceneRole = mSceneRoleService.queryRoleDetail(queryRoleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


            sceneRole_1 = sceneRole;
            String string_6 = null;
            if (string_4 != null && string != null) {
                OriginalRoleMember originalRoleMember = new OriginalRoleMember();
                originalRoleMember.setSource("SET_WITHIN_ORG");//sourceId:20754_1_3934
                originalRoleMember.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:20756_1_3934
                originalRoleMember.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:20757_1_3934
                originalRoleMember.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:20758_1_3934
                if (string_4 != null) {
                    originalRoleMember.setMemberId(string_4);//SimpleFieldAssign//sourceId:20751_1_3934
                }
                if (sceneRole != null) {
                    originalRoleMember.setRoleCode(sceneRole.getRoleCode());//SimpleFieldAssign//sourceId:20759_1_3934
                    originalRoleMember.setRoleId(sceneRole.getRoleId());//SimpleFieldAssign//sourceId:47304_1_3934
                }
                if (string != null) {
                    originalRoleMember.setUserId(string);//SimpleFieldAssign//sourceId:47303_1_3934
                }
                if (reqDto != null) {
                    originalRoleMember.setFirstLetter(CommonFunctionHelper.firstChar(reqDto.getIdCardName()));//FIRST_CHAR //todo 字段备注首位字母来源为空,请设置!!;//sourceId:20753_1_3934
                }

                /*1-2-09新增身份人员[77] 获取上一步出参的成员ID，还有前端固化的角色编码STAFF，生成员工原始角色身份的成员关系ID（例如员工等）。  */
                Assert.isNull(originalRoleMember.getMemberId(), "D1-2新增员工身份人员-1-2-09新增身份人员-成员ID不能为空", false);
                Assert.isNull(originalRoleMember.getRoleCode(), "D1-2新增员工身份人员-1-2-09新增身份人员-身份角色编码不能为空", false);
                Assert.isNull(originalRoleMember.getUserId(), "D1-2新增员工身份人员-1-2-09新增身份人员-账号ID不能为空", false);
                Assert.isNull(originalRoleMember.getRoleId(), "D1-2新增员工身份人员-1-2-09新增身份人员-身份角色ID不能为空", false);
                Assert.isNull(originalRoleMember.getFirstLetter(), "D1-2新增员工身份人员-1-2-09新增身份人员-备注首位字母不能为空", false);
                Assert.isNull(originalRoleMember.getSource(), "D1-2新增员工身份人员-1-2-09新增身份人员-关系建立来源不能为空", false);
                Assert.isNull(originalRoleMember.getSubjectLifeCycle(), "D1-2新增员工身份人员-1-2-09新增身份人员-主体生命周期不能为空", false);
                Assert.isNull(originalRoleMember.getSpaceId(), "D1-2新增员工身份人员-1-2-09新增身份人员-创建于空间ID不能为空", false);
                Assert.isNull(originalRoleMember.getAppId(), "D1-2新增员工身份人员-1-2-09新增身份人员-创建于联盟应用ID不能为空", false);
                string_6 = mOriginalRoleMemberService.addBeginMember(originalRoleMember)/*vcase invoke 本地 method 方法调用;*/;


                string_7 = string_6;
            }
            String string_8 = null;
            if (string_6 != null) {
                OriginalRoleMemberInfo originalRoleMemberInfo = new OriginalRoleMemberInfo();
                originalRoleMemberInfo.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:20767_1_3935
                originalRoleMemberInfo.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:20768_1_3935
                if (string_6 != null) {
                    originalRoleMemberInfo.setOriginalRoleMemberId(string_6);//SimpleFieldAssign//sourceId:20761_1_3935
                }
                if (reqDto != null) {
                    originalRoleMemberInfo.setRoleMemberCode(reqDto.getRoleMemberCode());//SimpleFieldAssign//sourceId:20762_1_3935
                    originalRoleMemberInfo.setIsPtJob(reqDto.getIsPtJob());//SimpleFieldAssign//sourceId:37830_1_3935
                }

                /*1-2-10新增身份人员资料[113] 获取上一步出参的原始角色成员关系ID，创建原始角色成员关系资料（例如员工资料）；  */
                Assert.isNull(originalRoleMemberInfo.getOriginalRoleMemberId(), "D1-2新增员工身份人员-1-2-10新增身份人员资料-身份人员ID不能为空", false);
                Assert.isNull(originalRoleMemberInfo.getRoleMemberCode(), "D1-2新增员工身份人员-1-2-10新增身份人员资料-身份人员编号不能为空", false);
                Assert.isNull(originalRoleMemberInfo.getSpaceId(), "D1-2新增员工身份人员-1-2-10新增身份人员资料-创建于空间ID不能为空", false);
                Assert.isNull(originalRoleMemberInfo.getAppId(), "D1-2新增员工身份人员-1-2-10新增身份人员资料-创建于联盟应用ID不能为空", false);
                string_8 = mOriginalRoleMemberInfoService.addBeginMembInfo(originalRoleMemberInfo)/*vcase invoke 本地 method 方法调用;*/;


                string_9 = string_8;
            }
            String string_10 = null;
            if (organization != null && string_6 != null && string != null && string_2 != null) {
                InductionRecord inductionRecord = new InductionRecord();
                inductionRecord.setInductionUnitTypeCode("ORG");//sourceId:20914_1_624
                inductionRecord.setIsMainInduction("TRUE");//sourceId:20923_1_624
                inductionRecord.setIsCustomPosition("TRUE");//sourceId:20924_1_624
                inductionRecord.setPositionIdName("成员");//CUSTOM_CONVENTION//sourceId:20928_1_624
                inductionRecord.setPositionType("MEMBER");//sourceId:281852_1_624
                inductionRecord.setIsDirector("FALSE");//sourceId:246857_1_624
                inductionRecord.setInductionStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:37821_1_624
                inductionRecord.setOrderNumber(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:285164_1_624
                inductionRecord.setIsUpdate("FALSE");//sourceId:281854_1_624
                inductionRecord.setUpdateStatus("UNCHANGED");//sourceId:281855_1_624
                inductionRecord.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:22137_1_624
                inductionRecord.setIsEditing("FALSE");//sourceId:29303_1_624
                inductionRecord.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:50498_1_624
                inductionRecord.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:50499_1_624
                if (organization != null) {
                    inductionRecord.setEntityId(organization.getOrganizationId());//SimpleFieldAssign//sourceId:20915_1_624
                    inductionRecord.setOrganizationId(organization.getOrganizationId());//SimpleFieldAssign//sourceId:20918_1_624
                }
                if (string_6 != null) {
                    inductionRecord.setOriginalRoleMemberId(string_6);//SimpleFieldAssign//sourceId:20916_1_624
                }
                if (string != null) {
                    inductionRecord.setUserId(string);//SimpleFieldAssign//sourceId:20917_1_624
                }
                if (string_2 != null) {
                    inductionRecord.setFirstLetter(string_2);//SimpleFieldAssign//sourceId:22947_1_624
                }
                if (reqDto != null) {
                    inductionRecord.setDirectorInductionRecordId(reqDto.getDirectorInductionRecordId());//SimpleFieldAssign//sourceId:20945_1_624
                }

    /*1-3-13新增就职记录[162] 根据上一步的无组织架构模式，执行此步自动生成就职记录ID；
【未来：职务名称可前端固化入参，也可在原始角色成员关系列表处二次修改，也包含主管就职记录的选择；】  */
                Assert.isNull(inductionRecord.getInductionUnitTypeCode(), "D1-2新增员工身份人员-1-3-13新增就职记录-就职单位类型实例不能为空", false);
                Assert.isNull(inductionRecord.getEntityId(), "D1-2新增员工身份人员-1-3-13新增就职记录-就职单位对象实例ID不能为空", false);
                Assert.isNull(inductionRecord.getOriginalRoleMemberId(), "D1-2新增员工身份人员-1-3-13新增就职记录-身份人员ID不能为空", false);
                Assert.isNull(inductionRecord.getUserId(), "D1-2新增员工身份人员-1-3-13新增就职记录-个人账号ID不能为空", false);
                Assert.isNull(inductionRecord.getFirstLetter(), "D1-2新增员工身份人员-1-3-13新增就职记录-备注首位字母不能为空", false);
                Assert.isNull(inductionRecord.getOrganizationId(), "D1-2新增员工身份人员-1-3-13新增就职记录-组织ID不能为空", false);
                Assert.isNull(inductionRecord.getIsMainInduction(), "D1-2新增员工身份人员-1-3-13新增就职记录-是否主岗不能为空", false);
                Assert.isNull(inductionRecord.getIsCustomPosition(), "D1-2新增员工身份人员-1-3-13新增就职记录-是否自定义职务不能为空", false);
                Assert.isNull(inductionRecord.getPositionIdName(), "D1-2新增员工身份人员-1-3-13新增就职记录-必选冗余职务名称不能为空", false);
                Assert.isNull(inductionRecord.getPositionType(), "D1-2新增员工身份人员-1-3-13新增就职记录-职务性质不能为空", false);
                Assert.isNull(inductionRecord.getIsDirector(), "D1-2新增员工身份人员-1-3-13新增就职记录-是否主管不能为空", false);
                Assert.isNull(inductionRecord.getInductionStartTime(), "D1-2新增员工身份人员-1-3-13新增就职记录-就职开始时间不能为空", false);
                Assert.isNull(inductionRecord.getOrderNumber(), "D1-2新增员工身份人员-1-3-13新增就职记录-排序不能为空", false);
                Assert.isNull(inductionRecord.getIsUpdate(), "D1-2新增员工身份人员-1-3-13新增就职记录-批次下是否更新不能为空", false);
                Assert.isNull(inductionRecord.getUpdateStatus(), "D1-2新增员工身份人员-1-3-13新增就职记录-批次下更新状态不能为空", false);
                Assert.isNull(inductionRecord.getSubjectLifeCycle(), "D1-2新增员工身份人员-1-3-13新增就职记录-主体生命周期不能为空", false);
                Assert.isNull(inductionRecord.getIsEditing(), "D1-2新增员工身份人员-1-3-13新增就职记录-是否未来不能为空", false);
                Assert.isNull(inductionRecord.getSpaceId(), "D1-2新增员工身份人员-1-3-13新增就职记录-创建于空间ID不能为空", false);
                Assert.isNull(inductionRecord.getAppId(), "D1-2新增员工身份人员-1-3-13新增就职记录-创建于联盟应用ID不能为空", false);
                string_10 = mInductionRecordService.addInductionRecord(inductionRecord)/*vcase invoke 本地 method 方法调用;*/;


                string_11 = string_10;
            }
//processBranchName:正常结束 ,processBranchId:631

        } else if ((!(queryItemMatchResultToAnswerDetailComRespDto != null && queryItemMatchResultToAnswerDetailComRespDto.getOrgStructureModel() != null && queryItemMatchResultToAnswerDetailComRespDto.getOrgStructureModel().equals("NO_ORG")) && reqDto != null && reqDto.getVerificationCode() == null && users == null) || (!(queryItemMatchResultToAnswerDetailComRespDto != null && queryItemMatchResultToAnswerDetailComRespDto.getOrgStructureModel() != null && queryItemMatchResultToAnswerDetailComRespDto.getOrgStructureModel().equals("NO_ORG")) && checkCaptchaValidRes != null && checkCaptchaValidRes.getIsInvalid() != null && checkCaptchaValidRes.getIsInvalid().equals("TRUE") && users == null)) {
            //elseif((D2-3查询配置项匹配结果转答案(公共).空间组织架构模式 不等于 无组织架构 and D1-2新增员工身份人员.验证码 值等于空  and 1-2-01查询个人账号详情.出参 值等于空 ) or (D2-3查询配置项匹配结果转答案(公共).空间组织架构模式 不等于 无组织架构 and M-检测验证码是否有效（特殊方法）.是否有效 等于 是 and 1-2-01查询个人账号详情.出参 值等于空 ))  591

            JudgeAddPerfectStaffUsableComRespDto judgeAddPerfectStaffUsableComRespDto_2 = null;
            JudgeAddPerfectStaffUsableComReqDto judgeAddPerfectStaffUsableComReqDto_1 = new JudgeAddPerfectStaffUsableComReqDto();
            judgeAddPerfectStaffUsableComReqDto_1.setRoleCode("ORG_ADMIN");//CUSTOM_CONVENTION//sourceId:213934_1_54621
            judgeAddPerfectStaffUsableComReqDto_1.setPrivacyCode("MGT_ORG_POWER");//CUSTOM_CONVENTION//sourceId:213935_1_54621
            if (reqDto != null) {
                judgeAddPerfectStaffUsableComReqDto_1.setUserName(reqDto.getUserName());//SimpleFieldAssign//sourceId:213927_1_54621
                judgeAddPerfectStaffUsableComReqDto_1.setRoleMemberCode(reqDto.getRoleMemberCode());//SimpleFieldAssign//sourceId:213923_1_54621
                judgeAddPerfectStaffUsableComReqDto_1.setPhone(reqDto.getPhone());//SimpleFieldAssign//sourceId:213924_1_54621
            }

            /*D1判断注册完善员工操作可用(公共)[4015]   */
            Assert.isNull(judgeAddPerfectStaffUsableComReqDto_1.getRoleMemberCode(), "D1-2新增员工身份人员-D1判断注册完善员工操作可用(公共)-身份人员编号不能为空", false);
            Assert.isNull(judgeAddPerfectStaffUsableComReqDto_1.getRoleCode(), "D1-2新增员工身份人员-D1判断注册完善员工操作可用(公共)-角色标识不能为空", false);
            Assert.isNull(judgeAddPerfectStaffUsableComReqDto_1.getPrivacyCode(), "D1-2新增员工身份人员-D1判断注册完善员工操作可用(公共)-权限标识不能为空", false);
            judgeAddPerfectStaffUsableComRespDto_2 = judgeAddPerfectStaffUsableCom(judgeAddPerfectStaffUsableComReqDto_1)/*vcase invoke 同服务,同domain*/;
            Assert.isTrue(judgeAddPerfectStaffUsableComRespDto_2 == null || judgeAddPerfectStaffUsableComRespDto_2.getOutputNum() == null, "找不到数据，系统异常", false);


            String string_12 = null;
            Users users_3 = new Users();
            users_3.setPassByEmail("FALSE");//sourceId:20717_1_3936
            users_3.setDevName(CommonFunctionHelper.getEquipMent());//GET_EQUIPMENT//sourceId:45505_1_3936
            users_3.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:20731_1_3936
            users_3.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:20732_1_3936
            if (reqDto != null) {
                users_3.setPassword(reqDto.getPassword());//SimpleFieldAssign//sourceId:43900_1_3936
                users_3.setUserName(reqDto.getUserName());//SimpleFieldAssign//sourceId:45501_1_3936
                users_3.setPhone(reqDto.getPhone());//SimpleFieldAssign//sourceId:20718_1_3936
                users_3.setPassByPhone(reqDto.getPassByPhone());//SimpleFieldAssign//sourceId:20719_1_3936
                users_3.setIsPasswordExit(reqDto.getIsPasswordExit());//SimpleFieldAssign//sourceId:45502_1_3936
                users_3.setEmail(reqDto.getEmail());//SimpleFieldAssign//sourceId:45503_1_3936
                users_3.setIsUserInfoDone(reqDto.getIsUserInfoDone());//SimpleFieldAssign//sourceId:45504_1_3936
                users_3.setSenceId(reqDto.getSenceId());//SimpleFieldAssign//sourceId:45507_1_3936
            }

            /*1-2-01新增个人账号[45] 前面判断没有个人账号，执行此步注册账号  */
            Assert.isNull(users_3.getPassByEmail(), "D1-2新增员工身份人员-1-2-01新增个人账号-邮箱激活状态不能为空", false);
            Assert.isNull(users_3.getPassword(), "D1-2新增员工身份人员-1-2-01新增个人账号-密码不能为空", false);
            Assert.isNull(users_3.getPhone(), "D1-2新增员工身份人员-1-2-01新增个人账号-绑定手机不能为空", false);
            Assert.isNull(users_3.getPassByPhone(), "D1-2新增员工身份人员-1-2-01新增个人账号-手机激活状态不能为空", false);
            Assert.isNull(users_3.getIsPasswordExit(), "D1-2新增员工身份人员-1-2-01新增个人账号-密码是否为空不能为空", false);
            Assert.isNull(users_3.getIsUserInfoDone(), "D1-2新增员工身份人员-1-2-01新增个人账号-个人资料是否完善不能为空", false);
            Assert.isNull(users_3.getSenceId(), "D1-2新增员工身份人员-1-2-01新增个人账号-归属于场景ID不能为空", false);
            Assert.isNull(users_3.getSpaceId(), "D1-2新增员工身份人员-1-2-01新增个人账号-创建于空间ID不能为空", false);
            Assert.isNull(users_3.getAppId(), "D1-2新增员工身份人员-1-2-01新增个人账号-创建于联盟应用ID不能为空", false);
            string_12 = mUsersService.addUser(users_3)/*vcase invoke 本地 method 方法调用;*/;


            string_1 = string_12;
            String string_13 = null;
            if (string_12 != null) {
                Userinfo userinfo_1 = new Userinfo();
                userinfo_1.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:20743_1_3937
                userinfo_1.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:20744_1_3937
                if (string_12 != null) {
                    userinfo_1.setUserId(string_12);//SimpleFieldAssign//sourceId:20735_1_3937
                }
                if (reqDto != null) {
                    userinfo_1.setIdCardName(reqDto.getIdCardName());//SimpleFieldAssign//sourceId:20736_1_3937
                    userinfo_1.setFirstLetter(CommonFunctionHelper.firstChar(reqDto.getIdCardName()));//FIRST_CHAR //todo 字段备注首位字母来源为空,请设置!!;//sourceId:56814_1_3937
                    userinfo_1.setUserFace(reqDto.getUserFace());//SimpleFieldAssign//sourceId:20738_1_3937
                }


                /*1-2-02新增个人资料[49] 根据上一步入参的个人账号ID，生成个人资料。  */
                Assert.isNull(userinfo_1.getUserId(), "D1-2新增员工身份人员-1-2-02新增个人资料-账号不能为空", false);
                Assert.isNull(userinfo_1.getIdCardName(), "D1-2新增员工身份人员-1-2-02新增个人资料-真实姓名不能为空", false);
                Assert.isNull(userinfo_1.getFirstLetter(), "D1-2新增员工身份人员-1-2-02新增个人资料-备注首位字母不能为空", false);
                Assert.isNull(userinfo_1.getUserFace(), "D1-2新增员工身份人员-1-2-02新增个人资料-真实头像不能为空", false);
                Assert.isNull(userinfo_1.getSpaceId(), "D1-2新增员工身份人员-1-2-02新增个人资料-创建于空间ID不能为空", false);
                Assert.isNull(userinfo_1.getAppId(), "D1-2新增员工身份人员-1-2-02新增个人资料-归属应用ID不能为空", false);
                string_13 = mUserinfoService.addUserinfo(userinfo_1)/*vcase invoke 本地 method 方法调用;*/;


                string_3 = string_13;
            }
            String string_14 = null;
            if (string_12 != null) {
                SpaceMember spaceMember_1 = new SpaceMember();
                spaceMember_1.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:20748_1_3938
                spaceMember_1.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:20749_1_3938
                if (string_12 != null) {
                    spaceMember_1.setUserId(string_12);//SimpleFieldAssign//sourceId:20747_1_3938
                }

                /*1-2-05新增空间成员关系[61] 上一步注册个人账号成功出参后，本步生成成员ID  */
                Assert.isNull(spaceMember_1.getUserId(), "D1-2新增员工身份人员-1-2-05新增空间成员关系-成员个人账号不能为空", false);
                Assert.isNull(spaceMember_1.getSpaceId(), "D1-2新增员工身份人员-1-2-05新增空间成员关系-创建于空间ID不能为空", false);
                Assert.isNull(spaceMember_1.getAppId(), "D1-2新增员工身份人员-1-2-05新增空间成员关系-创建于联盟应用ID不能为空", false);
                string_14 = mSpaceMemberService.addMember(spaceMember_1)/*vcase invoke 本地 method 方法调用;*/;


                string_5 = string_14;
            }
            SceneRole sceneRole_2 = null;
            QueryRoleDetailReq queryRoleDetailReq_1 = new QueryRoleDetailReq();
            queryRoleDetailReq_1.setRoleCode("STAFF");//CUSTOM_CONVENTION//sourceId:23851_1_3939
            queryRoleDetailReq_1.setIsIdentity("TRUE");//sourceId:23852_1_3939
            queryRoleDetailReq_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:23853_1_3939

            /*1-2-08查询角色详情[170] 查询员工原始角色STAFF，出参角色ID  */
            Assert.isNull(queryRoleDetailReq_1.getRoleCode(), "D1-2新增员工身份人员-1-2-08查询角色详情-角色标识不能为空", false);
            Assert.isNull(queryRoleDetailReq_1.getIsIdentity(), "D1-2新增员工身份人员-1-2-08查询角色详情-是否身份角色不能为空", false);
            Assert.isNull(queryRoleDetailReq_1.getSubjectLifeCycle(), "D1-2新增员工身份人员-1-2-08查询角色详情-主体生命周期不能为空", false);
            sceneRole_2 = mSceneRoleService.queryRoleDetail(queryRoleDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;


            sceneRole_1 = sceneRole_2;
            String string_15 = null;
            if (string_14 != null && string_12 != null) {
                OriginalRoleMember originalRoleMember_1 = new OriginalRoleMember();
                originalRoleMember_1.setSource("SET_WITHIN_ORG");//sourceId:20754_1_3940
                originalRoleMember_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:20756_1_3940
                originalRoleMember_1.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:20757_1_3940
                originalRoleMember_1.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:20758_1_3940
                if (string_14 != null) {
                    originalRoleMember_1.setMemberId(string_14);//SimpleFieldAssign//sourceId:20751_1_3940
                }
                if (sceneRole_2 != null) {
                    originalRoleMember_1.setRoleCode(sceneRole_2.getRoleCode());//SimpleFieldAssign//sourceId:20759_1_3940
                    originalRoleMember_1.setRoleId(sceneRole_2.getRoleId());//SimpleFieldAssign//sourceId:47304_1_3940
                }
                if (string_12 != null) {
                    originalRoleMember_1.setUserId(string_12);//SimpleFieldAssign//sourceId:47303_1_3940
                }
                if (reqDto != null) {
                    originalRoleMember_1.setFirstLetter(CommonFunctionHelper.firstChar(reqDto.getIdCardName()));//FIRST_CHAR //todo 字段备注首位字母来源为空,请设置!!;//sourceId:20753_1_3940
                }

                /*1-2-09新增身份人员[77] 获取上一步出参的成员ID，还有前端固化的角色编码STAFF，生成员工原始角色身份的成员关系ID（例如员工等）。  */
                Assert.isNull(originalRoleMember_1.getMemberId(), "D1-2新增员工身份人员-1-2-09新增身份人员-成员ID不能为空", false);
                Assert.isNull(originalRoleMember_1.getRoleCode(), "D1-2新增员工身份人员-1-2-09新增身份人员-身份角色编码不能为空", false);
                Assert.isNull(originalRoleMember_1.getUserId(), "D1-2新增员工身份人员-1-2-09新增身份人员-账号ID不能为空", false);
                Assert.isNull(originalRoleMember_1.getRoleId(), "D1-2新增员工身份人员-1-2-09新增身份人员-身份角色ID不能为空", false);
                Assert.isNull(originalRoleMember_1.getFirstLetter(), "D1-2新增员工身份人员-1-2-09新增身份人员-备注首位字母不能为空", false);
                Assert.isNull(originalRoleMember_1.getSource(), "D1-2新增员工身份人员-1-2-09新增身份人员-关系建立来源不能为空", false);
                Assert.isNull(originalRoleMember_1.getSubjectLifeCycle(), "D1-2新增员工身份人员-1-2-09新增身份人员-主体生命周期不能为空", false);
                Assert.isNull(originalRoleMember_1.getSpaceId(), "D1-2新增员工身份人员-1-2-09新增身份人员-创建于空间ID不能为空", false);
                Assert.isNull(originalRoleMember_1.getAppId(), "D1-2新增员工身份人员-1-2-09新增身份人员-创建于联盟应用ID不能为空", false);
                string_15 = mOriginalRoleMemberService.addBeginMember(originalRoleMember_1)/*vcase invoke 本地 method 方法调用;*/;


                string_7 = string_15;
            }
            String string_16 = null;
            if (string_15 != null) {
                OriginalRoleMemberInfo originalRoleMemberInfo_1 = new OriginalRoleMemberInfo();
                originalRoleMemberInfo_1.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:20767_1_3941
                originalRoleMemberInfo_1.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:20768_1_3941
                if (string_15 != null) {
                    originalRoleMemberInfo_1.setOriginalRoleMemberId(string_15);//SimpleFieldAssign//sourceId:20761_1_3941
                }
                if (reqDto != null) {
                    originalRoleMemberInfo_1.setRoleMemberCode(reqDto.getRoleMemberCode());//SimpleFieldAssign//sourceId:20762_1_3941
                    originalRoleMemberInfo_1.setIsPtJob(reqDto.getIsPtJob());//SimpleFieldAssign//sourceId:37830_1_3941
                }

                /*1-2-10新增身份人员资料[113] 获取上一步出参的原始角色成员关系ID，创建原始角色成员关系资料（例如员工资料）；  */
                Assert.isNull(originalRoleMemberInfo_1.getOriginalRoleMemberId(), "D1-2新增员工身份人员-1-2-10新增身份人员资料-身份人员ID不能为空", false);
                Assert.isNull(originalRoleMemberInfo_1.getRoleMemberCode(), "D1-2新增员工身份人员-1-2-10新增身份人员资料-身份人员编号不能为空", false);
                Assert.isNull(originalRoleMemberInfo_1.getSpaceId(), "D1-2新增员工身份人员-1-2-10新增身份人员资料-创建于空间ID不能为空", false);
                Assert.isNull(originalRoleMemberInfo_1.getAppId(), "D1-2新增员工身份人员-1-2-10新增身份人员资料-创建于联盟应用ID不能为空", false);
                string_16 = mOriginalRoleMemberInfoService.addBeginMembInfo(originalRoleMemberInfo_1)/*vcase invoke 本地 method 方法调用;*/;


                string_9 = string_16;
            }
//processBranchName:正常结束 ,processBranchId:632

        } else if ((users != null)) {
            //elseif(1-2-01查询个人账号详情.出参 不等于空 )  2253

            JudgeAddPerfectStaffUsableComRespDto judgeAddPerfectStaffUsableComRespDto_3 = null;
            JudgeAddPerfectStaffUsableComReqDto judgeAddPerfectStaffUsableComReqDto_2 = new JudgeAddPerfectStaffUsableComReqDto();
            judgeAddPerfectStaffUsableComReqDto_2.setRoleCode("ORG_ADMIN");//CUSTOM_CONVENTION//sourceId:213934_1_54622
            judgeAddPerfectStaffUsableComReqDto_2.setPrivacyCode("MGT_ORG_POWER");//CUSTOM_CONVENTION//sourceId:213935_1_54622
            if (reqDto != null) {
                judgeAddPerfectStaffUsableComReqDto_2.setRoleMemberCode(reqDto.getRoleMemberCode());//SimpleFieldAssign//sourceId:213923_1_54622
            }

            /*D1判断注册完善员工操作可用(公共)[4015]   */
            Assert.isNull(judgeAddPerfectStaffUsableComReqDto_2.getRoleMemberCode(), "D1-2新增员工身份人员-D1判断注册完善员工操作可用(公共)-身份人员编号不能为空", false);
            Assert.isNull(judgeAddPerfectStaffUsableComReqDto_2.getRoleCode(), "D1-2新增员工身份人员-D1判断注册完善员工操作可用(公共)-角色标识不能为空", false);
            Assert.isNull(judgeAddPerfectStaffUsableComReqDto_2.getPrivacyCode(), "D1-2新增员工身份人员-D1判断注册完善员工操作可用(公共)-权限标识不能为空", false);
            judgeAddPerfectStaffUsableComRespDto_3 = judgeAddPerfectStaffUsableCom(judgeAddPerfectStaffUsableComReqDto_2)/*vcase invoke 同服务,同domain*/;
            Assert.isTrue(judgeAddPerfectStaffUsableComRespDto_3 == null || judgeAddPerfectStaffUsableComRespDto_3.getOutputNum() == null, "找不到数据，系统异常", false);


            SpaceMember spaceMember_2 = null;
            if (users != null) {
                QueryMemberDetailReq queryMemberDetailReq = new QueryMemberDetailReq();
                queryMemberDetailReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:20713_1_2255
                if (users != null) {
                    queryMemberDetailReq.setUserId(users.getUserId());//SimpleFieldAssign//sourceId:20712_1_2255
                }

                /*1-2-05查询空间成员关系详情[167] 通过上一步出参的个人账号查询成员ID，无就结束查询，执行下一步生成成员ID，；如果有成员ID就出参（表示已经是成员，前端报错告知有此人，不可设成员）  */
                Assert.isNull(queryMemberDetailReq.getUserId(), "D1-2新增员工身份人员-1-2-05查询空间成员关系详情-成员个人账号不能为空", false);
                Assert.isNull(queryMemberDetailReq.getSpaceId(), "D1-2新增员工身份人员-1-2-05查询空间成员关系详情-创建于空间ID不能为空", false);
                spaceMember_2 = mSpaceMemberService.queryMemberDetail(queryMemberDetailReq)/*vcase invoke 本地 method 方法调用;*/;


            }
            if ((queryItemMatchResultToAnswerDetailComRespDto != null && queryItemMatchResultToAnswerDetailComRespDto.getOrgStructureModel() != null && queryItemMatchResultToAnswerDetailComRespDto.getOrgStructureModel().equals("NO_ORG") && reqDto != null && reqDto.getVerificationCode() == null && users != null) || (queryItemMatchResultToAnswerDetailComRespDto != null && queryItemMatchResultToAnswerDetailComRespDto.getOrgStructureModel() != null && queryItemMatchResultToAnswerDetailComRespDto.getOrgStructureModel().equals("NO_ORG") && checkCaptchaValidRes != null && checkCaptchaValidRes.getIsInvalid() != null && checkCaptchaValidRes.getIsInvalid().equals("TRUE") && users != null)) {
                //if((D2-3查询配置项匹配结果转答案(公共).空间组织架构模式 等于 无组织架构 and D1-2新增员工身份人员.验证码 值等于空  and 1-2-01查询个人账号详情.出参 值不等于空 ) or (D2-3查询配置项匹配结果转答案(公共).空间组织架构模式 等于 无组织架构 and M-检测验证码是否有效（特殊方法）.是否有效 等于 是 and 1-2-01查询个人账号详情.出参 值不等于空 ))  2256

                String string_17 = null;
                if (users != null) {
                    SpaceMember spaceMember_4 = new SpaceMember();
                    spaceMember_4.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:20748_1_3942
                    spaceMember_4.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:20749_1_3942
                    if (users != null) {
                        spaceMember_4.setUserId(users.getUserId());//SimpleFieldAssign//sourceId:20747_1_3942
                    }

                    /*1-2-05新增空间成员关系[61] 上一步注册个人账号成功出参后，本步生成成员ID  */
                    Assert.isNull(spaceMember_4.getUserId(), "D1-2新增员工身份人员-1-2-05新增空间成员关系-成员个人账号不能为空", false);
                    Assert.isNull(spaceMember_4.getSpaceId(), "D1-2新增员工身份人员-1-2-05新增空间成员关系-创建于空间ID不能为空", false);
                    Assert.isNull(spaceMember_4.getAppId(), "D1-2新增员工身份人员-1-2-05新增空间成员关系-创建于联盟应用ID不能为空", false);
                    string_17 = mSpaceMemberService.addMember(spaceMember_4)/*vcase invoke 本地 method 方法调用;*/;


                    string_5 = string_17;
                }
                SceneRole sceneRole_3 = null;
                QueryRoleDetailReq queryRoleDetailReq_2 = new QueryRoleDetailReq();
                queryRoleDetailReq_2.setRoleCode("STAFF");//CUSTOM_CONVENTION//sourceId:23851_1_3943
                queryRoleDetailReq_2.setIsIdentity("TRUE");//sourceId:23852_1_3943
                queryRoleDetailReq_2.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:23853_1_3943

                /*1-2-08查询角色详情[170] 查询员工原始角色STAFF，出参角色ID  */
                Assert.isNull(queryRoleDetailReq_2.getRoleCode(), "D1-2新增员工身份人员-1-2-08查询角色详情-角色标识不能为空", false);
                Assert.isNull(queryRoleDetailReq_2.getIsIdentity(), "D1-2新增员工身份人员-1-2-08查询角色详情-是否身份角色不能为空", false);
                Assert.isNull(queryRoleDetailReq_2.getSubjectLifeCycle(), "D1-2新增员工身份人员-1-2-08查询角色详情-主体生命周期不能为空", false);
                sceneRole_3 = mSceneRoleService.queryRoleDetail(queryRoleDetailReq_2)/*vcase invoke 本地 method 方法调用;*/;


                sceneRole_1 = sceneRole_3;
                Userinfo userinfo_2 = null;
                if (users != null) {
                    QueryUserinfoDetailReq queryUserinfoDetailReq = new QueryUserinfoDetailReq();
                    if (users != null) {
                        queryUserinfoDetailReq.setUserId(users.getUserId());//SimpleFieldAssign//sourceId:41851_1_3944
                    }

                    /*1-2-02查询个人资料详情（查首字母）[155]   */
                    Assert.isNull(queryUserinfoDetailReq.getUserId(), "D1-2新增员工身份人员-1-2-02查询个人资料详情（查首字母）-账号不能为空", false);
                    userinfo_2 = mUserinfoService.queryUserinfoDetail(queryUserinfoDetailReq)/*vcase invoke 本地 method 方法调用;*/;


                    userinfo_3 = userinfo_2;
                }
                String string_18 = null;
                if (string_17 != null && users != null) {
                    OriginalRoleMember originalRoleMember_2 = new OriginalRoleMember();
                    originalRoleMember_2.setSource("SET_WITHIN_ORG");//sourceId:20754_1_3945
                    originalRoleMember_2.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:20756_1_3945
                    originalRoleMember_2.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:20757_1_3945
                    originalRoleMember_2.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:20758_1_3945
                    if (string_17 != null) {
                        originalRoleMember_2.setMemberId(string_17);//SimpleFieldAssign//sourceId:20751_1_3945
                    }
                    if (sceneRole_3 != null) {
                        originalRoleMember_2.setRoleCode(sceneRole_3.getRoleCode());//SimpleFieldAssign//sourceId:20759_1_3945
                        originalRoleMember_2.setRoleId(sceneRole_3.getRoleId());//SimpleFieldAssign//sourceId:47304_1_3945
                    }
                    if (users != null) {
                        originalRoleMember_2.setUserId(users.getUserId());//SimpleFieldAssign//sourceId:47303_1_3945
                    }
                    if (reqDto != null) {
                        originalRoleMember_2.setFirstLetter(CommonFunctionHelper.firstChar(reqDto.getIdCardName()));//FIRST_CHAR //todo 字段备注首位字母来源为空,请设置!!;//sourceId:20753_1_3945
                    }

                    /*1-2-09新增身份人员[77] 获取上一步出参的成员ID，还有前端固化的角色编码STAFF，生成员工原始角色身份的成员关系ID（例如员工等）。  */
                    Assert.isNull(originalRoleMember_2.getMemberId(), "D1-2新增员工身份人员-1-2-09新增身份人员-成员ID不能为空", false);
                    Assert.isNull(originalRoleMember_2.getRoleCode(), "D1-2新增员工身份人员-1-2-09新增身份人员-身份角色编码不能为空", false);
                    Assert.isNull(originalRoleMember_2.getUserId(), "D1-2新增员工身份人员-1-2-09新增身份人员-账号ID不能为空", false);
                    Assert.isNull(originalRoleMember_2.getRoleId(), "D1-2新增员工身份人员-1-2-09新增身份人员-身份角色ID不能为空", false);
                    Assert.isNull(originalRoleMember_2.getFirstLetter(), "D1-2新增员工身份人员-1-2-09新增身份人员-备注首位字母不能为空", false);
                    Assert.isNull(originalRoleMember_2.getSource(), "D1-2新增员工身份人员-1-2-09新增身份人员-关系建立来源不能为空", false);
                    Assert.isNull(originalRoleMember_2.getSubjectLifeCycle(), "D1-2新增员工身份人员-1-2-09新增身份人员-主体生命周期不能为空", false);
                    Assert.isNull(originalRoleMember_2.getSpaceId(), "D1-2新增员工身份人员-1-2-09新增身份人员-创建于空间ID不能为空", false);
                    Assert.isNull(originalRoleMember_2.getAppId(), "D1-2新增员工身份人员-1-2-09新增身份人员-创建于联盟应用ID不能为空", false);
                    string_18 = mOriginalRoleMemberService.addBeginMember(originalRoleMember_2)/*vcase invoke 本地 method 方法调用;*/;


                    string_7 = string_18;
                }
                String string_19 = null;
                if (string_18 != null) {
                    OriginalRoleMemberInfo originalRoleMemberInfo_2 = new OriginalRoleMemberInfo();
                    originalRoleMemberInfo_2.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:20767_1_3946
                    originalRoleMemberInfo_2.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:20768_1_3946
                    if (string_18 != null) {
                        originalRoleMemberInfo_2.setOriginalRoleMemberId(string_18);//SimpleFieldAssign//sourceId:20761_1_3946
                    }
                    if (reqDto != null) {
                        originalRoleMemberInfo_2.setRoleMemberCode(reqDto.getRoleMemberCode());//SimpleFieldAssign//sourceId:20762_1_3946
                        originalRoleMemberInfo_2.setIsPtJob(reqDto.getIsPtJob());//SimpleFieldAssign//sourceId:37830_1_3946
                    }

                    /*1-2-10新增身份人员资料[113] 获取上一步出参的原始角色成员关系ID，创建原始角色成员关系资料（例如员工资料）；  */
                    Assert.isNull(originalRoleMemberInfo_2.getOriginalRoleMemberId(), "D1-2新增员工身份人员-1-2-10新增身份人员资料-身份人员ID不能为空", false);
                    Assert.isNull(originalRoleMemberInfo_2.getRoleMemberCode(), "D1-2新增员工身份人员-1-2-10新增身份人员资料-身份人员编号不能为空", false);
                    Assert.isNull(originalRoleMemberInfo_2.getSpaceId(), "D1-2新增员工身份人员-1-2-10新增身份人员资料-创建于空间ID不能为空", false);
                    Assert.isNull(originalRoleMemberInfo_2.getAppId(), "D1-2新增员工身份人员-1-2-10新增身份人员资料-创建于联盟应用ID不能为空", false);
                    string_19 = mOriginalRoleMemberInfoService.addBeginMembInfo(originalRoleMemberInfo_2)/*vcase invoke 本地 method 方法调用;*/;


                    string_9 = string_19;
                }
                String string_20 = null;
                if (organization != null && string_18 != null && users != null && userinfo_2 != null) {
                    InductionRecord inductionRecord_1 = new InductionRecord();
                    inductionRecord_1.setInductionUnitTypeCode("ORG");//sourceId:20914_1_2263
                    inductionRecord_1.setIsMainInduction("TRUE");//sourceId:20923_1_2263
                    inductionRecord_1.setIsCustomPosition("TRUE");//sourceId:20924_1_2263
                    inductionRecord_1.setPositionIdName("成员");//CUSTOM_CONVENTION//sourceId:20928_1_2263
                    inductionRecord_1.setPositionType("MEMBER");//sourceId:281852_1_2263
                    inductionRecord_1.setIsDirector("FALSE");//sourceId:246857_1_2263
                    inductionRecord_1.setInductionStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:37821_1_2263
                    inductionRecord_1.setOrderNumber(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:285164_1_2263
                    inductionRecord_1.setIsUpdate("FALSE");//sourceId:281854_1_2263
                    inductionRecord_1.setUpdateStatus("UNCHANGED");//sourceId:281855_1_2263
                    inductionRecord_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:22137_1_2263
                    inductionRecord_1.setIsEditing("FALSE");//sourceId:29303_1_2263
                    inductionRecord_1.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:50498_1_2263
                    inductionRecord_1.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:50499_1_2263
                    if (organization != null) {
                        inductionRecord_1.setEntityId(organization.getOrganizationId());//SimpleFieldAssign//sourceId:20915_1_2263
                        inductionRecord_1.setOrganizationId(organization.getOrganizationId());//SimpleFieldAssign//sourceId:20918_1_2263
                    }
                    if (string_18 != null) {
                        inductionRecord_1.setOriginalRoleMemberId(string_18);//SimpleFieldAssign//sourceId:20916_1_2263
                    }
                    if (users != null) {
                        inductionRecord_1.setUserId(users.getUserId());//SimpleFieldAssign//sourceId:20917_1_2263
                    }
                    if (userinfo_2 != null) {
                        inductionRecord_1.setFirstLetter(userinfo_2.getFirstLetter());//SimpleFieldAssign//sourceId:22947_1_2263
                    }
                    if (reqDto != null) {
                        inductionRecord_1.setDirectorInductionRecordId(reqDto.getDirectorInductionRecordId());//SimpleFieldAssign//sourceId:20945_1_2263
                    }

    /*1-3-13新增就职记录[162] 根据上一步的无组织架构模式，执行此步自动生成就职记录ID；
【未来：职务名称可前端固化入参，也可在原始角色成员关系列表处二次修改，也包含主管就职记录的选择；】  */
                    Assert.isNull(inductionRecord_1.getInductionUnitTypeCode(), "D1-2新增员工身份人员-1-3-13新增就职记录-就职单位类型实例不能为空", false);
                    Assert.isNull(inductionRecord_1.getEntityId(), "D1-2新增员工身份人员-1-3-13新增就职记录-就职单位对象实例ID不能为空", false);
                    Assert.isNull(inductionRecord_1.getOriginalRoleMemberId(), "D1-2新增员工身份人员-1-3-13新增就职记录-身份人员ID不能为空", false);
                    Assert.isNull(inductionRecord_1.getUserId(), "D1-2新增员工身份人员-1-3-13新增就职记录-个人账号ID不能为空", false);
                    Assert.isNull(inductionRecord_1.getFirstLetter(), "D1-2新增员工身份人员-1-3-13新增就职记录-备注首位字母不能为空", false);
                    Assert.isNull(inductionRecord_1.getOrganizationId(), "D1-2新增员工身份人员-1-3-13新增就职记录-组织ID不能为空", false);
                    Assert.isNull(inductionRecord_1.getIsMainInduction(), "D1-2新增员工身份人员-1-3-13新增就职记录-是否主岗不能为空", false);
                    Assert.isNull(inductionRecord_1.getIsCustomPosition(), "D1-2新增员工身份人员-1-3-13新增就职记录-是否自定义职务不能为空", false);
                    Assert.isNull(inductionRecord_1.getPositionIdName(), "D1-2新增员工身份人员-1-3-13新增就职记录-必选冗余职务名称不能为空", false);
                    Assert.isNull(inductionRecord_1.getPositionType(), "D1-2新增员工身份人员-1-3-13新增就职记录-职务性质不能为空", false);
                    Assert.isNull(inductionRecord_1.getIsDirector(), "D1-2新增员工身份人员-1-3-13新增就职记录-是否主管不能为空", false);
                    Assert.isNull(inductionRecord_1.getInductionStartTime(), "D1-2新增员工身份人员-1-3-13新增就职记录-就职开始时间不能为空", false);
                    Assert.isNull(inductionRecord_1.getOrderNumber(), "D1-2新增员工身份人员-1-3-13新增就职记录-排序不能为空", false);
                    Assert.isNull(inductionRecord_1.getIsUpdate(), "D1-2新增员工身份人员-1-3-13新增就职记录-批次下是否更新不能为空", false);
                    Assert.isNull(inductionRecord_1.getUpdateStatus(), "D1-2新增员工身份人员-1-3-13新增就职记录-批次下更新状态不能为空", false);
                    Assert.isNull(inductionRecord_1.getSubjectLifeCycle(), "D1-2新增员工身份人员-1-3-13新增就职记录-主体生命周期不能为空", false);
                    Assert.isNull(inductionRecord_1.getIsEditing(), "D1-2新增员工身份人员-1-3-13新增就职记录-是否未来不能为空", false);
                    Assert.isNull(inductionRecord_1.getSpaceId(), "D1-2新增员工身份人员-1-3-13新增就职记录-创建于空间ID不能为空", false);
                    Assert.isNull(inductionRecord_1.getAppId(), "D1-2新增员工身份人员-1-3-13新增就职记录-创建于联盟应用ID不能为空", false);
                    string_20 = mInductionRecordService.addInductionRecord(inductionRecord_1)/*vcase invoke 本地 method 方法调用;*/;


                    string_11 = string_20;
                }
//processBranchName:正常结束 ,processBranchId:2264

            } else if ((!(queryItemMatchResultToAnswerDetailComRespDto != null && queryItemMatchResultToAnswerDetailComRespDto.getOrgStructureModel() != null && queryItemMatchResultToAnswerDetailComRespDto.getOrgStructureModel().equals("NO_ORG")) && reqDto != null && reqDto.getVerificationCode() == null && users != null) || (!(queryItemMatchResultToAnswerDetailComRespDto != null && queryItemMatchResultToAnswerDetailComRespDto.getOrgStructureModel() != null && queryItemMatchResultToAnswerDetailComRespDto.getOrgStructureModel().equals("NO_ORG")) && checkCaptchaValidRes != null && checkCaptchaValidRes.getIsInvalid() != null && checkCaptchaValidRes.getIsInvalid().equals("TRUE") && users != null)) {
                //elseif((D2-3查询配置项匹配结果转答案(公共).空间组织架构模式 不等于 无组织架构 and D1-2新增员工身份人员.验证码 值等于空  and 1-2-01查询个人账号详情.出参 值不等于空 ) or (D2-3查询配置项匹配结果转答案(公共).空间组织架构模式 不等于 无组织架构 and M-检测验证码是否有效（特殊方法）.是否有效 等于 是 and 1-2-01查询个人账号详情.出参 值不等于空 ))  2258

                String string_21 = null;
                if (users != null) {
                    SpaceMember spaceMember_5 = new SpaceMember();
                    spaceMember_5.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:20748_1_3947
                    spaceMember_5.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:20749_1_3947
                    if (users != null) {
                        spaceMember_5.setUserId(users.getUserId());//SimpleFieldAssign//sourceId:20747_1_3947
                    }

                    /*1-2-05新增空间成员关系[61] 上一步注册个人账号成功出参后，本步生成成员ID  */
                    Assert.isNull(spaceMember_5.getUserId(), "D1-2新增员工身份人员-1-2-05新增空间成员关系-成员个人账号不能为空", false);
                    Assert.isNull(spaceMember_5.getSpaceId(), "D1-2新增员工身份人员-1-2-05新增空间成员关系-创建于空间ID不能为空", false);
                    Assert.isNull(spaceMember_5.getAppId(), "D1-2新增员工身份人员-1-2-05新增空间成员关系-创建于联盟应用ID不能为空", false);
                    string_21 = mSpaceMemberService.addMember(spaceMember_5)/*vcase invoke 本地 method 方法调用;*/;


                    string_5 = string_21;
                }
                SceneRole sceneRole_4 = null;
                QueryRoleDetailReq queryRoleDetailReq_3 = new QueryRoleDetailReq();
                queryRoleDetailReq_3.setRoleCode("STAFF");//CUSTOM_CONVENTION//sourceId:23851_1_3948
                queryRoleDetailReq_3.setIsIdentity("TRUE");//sourceId:23852_1_3948
                queryRoleDetailReq_3.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:23853_1_3948

                /*1-2-08查询角色详情[170] 查询员工原始角色STAFF，出参角色ID  */
                Assert.isNull(queryRoleDetailReq_3.getRoleCode(), "D1-2新增员工身份人员-1-2-08查询角色详情-角色标识不能为空", false);
                Assert.isNull(queryRoleDetailReq_3.getIsIdentity(), "D1-2新增员工身份人员-1-2-08查询角色详情-是否身份角色不能为空", false);
                Assert.isNull(queryRoleDetailReq_3.getSubjectLifeCycle(), "D1-2新增员工身份人员-1-2-08查询角色详情-主体生命周期不能为空", false);
                sceneRole_4 = mSceneRoleService.queryRoleDetail(queryRoleDetailReq_3)/*vcase invoke 本地 method 方法调用;*/;


                sceneRole_1 = sceneRole_4;
                Userinfo userinfo_4 = null;
                if (users != null) {
                    QueryUserinfoDetailReq queryUserinfoDetailReq_1 = new QueryUserinfoDetailReq();
                    if (users != null) {
                        queryUserinfoDetailReq_1.setUserId(users.getUserId());//SimpleFieldAssign//sourceId:41851_1_3949
                    }

                    /*1-2-02查询个人资料详情（查首字母）[155]   */
                    Assert.isNull(queryUserinfoDetailReq_1.getUserId(), "D1-2新增员工身份人员-1-2-02查询个人资料详情（查首字母）-账号不能为空", false);
                    userinfo_4 = mUserinfoService.queryUserinfoDetail(queryUserinfoDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;


                    userinfo_3 = userinfo_4;
                }
                String string_22 = null;
                if (string_21 != null && users != null) {
                    OriginalRoleMember originalRoleMember_3 = new OriginalRoleMember();
                    originalRoleMember_3.setSource("SET_WITHIN_ORG");//sourceId:20754_1_3950
                    originalRoleMember_3.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:20756_1_3950
                    originalRoleMember_3.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:20757_1_3950
                    originalRoleMember_3.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:20758_1_3950
                    if (string_21 != null) {
                        originalRoleMember_3.setMemberId(string_21);//SimpleFieldAssign//sourceId:20751_1_3950
                    }
                    if (sceneRole_4 != null) {
                        originalRoleMember_3.setRoleCode(sceneRole_4.getRoleCode());//SimpleFieldAssign//sourceId:20759_1_3950
                        originalRoleMember_3.setRoleId(sceneRole_4.getRoleId());//SimpleFieldAssign//sourceId:47304_1_3950
                    }
                    if (users != null) {
                        originalRoleMember_3.setUserId(users.getUserId());//SimpleFieldAssign//sourceId:47303_1_3950
                    }
                    if (reqDto != null) {
                        originalRoleMember_3.setFirstLetter(CommonFunctionHelper.firstChar(reqDto.getIdCardName()));//FIRST_CHAR //todo 字段备注首位字母来源为空,请设置!!;//sourceId:20753_1_3950
                    }

                    /*1-2-09新增身份人员[77] 获取上一步出参的成员ID，还有前端固化的角色编码STAFF，生成员工原始角色身份的成员关系ID（例如员工等）。  */
                    Assert.isNull(originalRoleMember_3.getMemberId(), "D1-2新增员工身份人员-1-2-09新增身份人员-成员ID不能为空", false);
                    Assert.isNull(originalRoleMember_3.getRoleCode(), "D1-2新增员工身份人员-1-2-09新增身份人员-身份角色编码不能为空", false);
                    Assert.isNull(originalRoleMember_3.getUserId(), "D1-2新增员工身份人员-1-2-09新增身份人员-账号ID不能为空", false);
                    Assert.isNull(originalRoleMember_3.getRoleId(), "D1-2新增员工身份人员-1-2-09新增身份人员-身份角色ID不能为空", false);
                    Assert.isNull(originalRoleMember_3.getFirstLetter(), "D1-2新增员工身份人员-1-2-09新增身份人员-备注首位字母不能为空", false);
                    Assert.isNull(originalRoleMember_3.getSource(), "D1-2新增员工身份人员-1-2-09新增身份人员-关系建立来源不能为空", false);
                    Assert.isNull(originalRoleMember_3.getSubjectLifeCycle(), "D1-2新增员工身份人员-1-2-09新增身份人员-主体生命周期不能为空", false);
                    Assert.isNull(originalRoleMember_3.getSpaceId(), "D1-2新增员工身份人员-1-2-09新增身份人员-创建于空间ID不能为空", false);
                    Assert.isNull(originalRoleMember_3.getAppId(), "D1-2新增员工身份人员-1-2-09新增身份人员-创建于联盟应用ID不能为空", false);
                    string_22 = mOriginalRoleMemberService.addBeginMember(originalRoleMember_3)/*vcase invoke 本地 method 方法调用;*/;


                    string_7 = string_22;
                }
                String string_23 = null;
                if (string_22 != null) {
                    OriginalRoleMemberInfo originalRoleMemberInfo_3 = new OriginalRoleMemberInfo();
                    originalRoleMemberInfo_3.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:20767_1_3951
                    originalRoleMemberInfo_3.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:20768_1_3951
                    if (string_22 != null) {
                        originalRoleMemberInfo_3.setOriginalRoleMemberId(string_22);//SimpleFieldAssign//sourceId:20761_1_3951
                    }
                    if (reqDto != null) {
                        originalRoleMemberInfo_3.setRoleMemberCode(reqDto.getRoleMemberCode());//SimpleFieldAssign//sourceId:20762_1_3951
                        originalRoleMemberInfo_3.setIsPtJob(reqDto.getIsPtJob());//SimpleFieldAssign//sourceId:37830_1_3951
                    }

                    /*1-2-10新增身份人员资料[113] 获取上一步出参的原始角色成员关系ID，创建原始角色成员关系资料（例如员工资料）；  */
                    Assert.isNull(originalRoleMemberInfo_3.getOriginalRoleMemberId(), "D1-2新增员工身份人员-1-2-10新增身份人员资料-身份人员ID不能为空", false);
                    Assert.isNull(originalRoleMemberInfo_3.getRoleMemberCode(), "D1-2新增员工身份人员-1-2-10新增身份人员资料-身份人员编号不能为空", false);
                    Assert.isNull(originalRoleMemberInfo_3.getSpaceId(), "D1-2新增员工身份人员-1-2-10新增身份人员资料-创建于空间ID不能为空", false);
                    Assert.isNull(originalRoleMemberInfo_3.getAppId(), "D1-2新增员工身份人员-1-2-10新增身份人员资料-创建于联盟应用ID不能为空", false);
                    string_23 = mOriginalRoleMemberInfoService.addBeginMembInfo(originalRoleMemberInfo_3)/*vcase invoke 本地 method 方法调用;*/;


                    string_9 = string_23;
                }
//processBranchName:正常结束 ,processBranchId:2270

            } else if ((spaceMember_2 != null)) {
                //elseif(1-2-05查询空间成员关系详情.出参 不等于空 )  2271

//异常结束 2274
                throw new BizException("10300031", "对不起，该成员已存在，无需重复添加！", false);
            }
        } else if ((reqDto != null && reqDto.getVerificationCode() != null && checkCaptchaValidRes != null && checkCaptchaValidRes.getIsInvalid() != null && checkCaptchaValidRes.getIsInvalid().equals("FALSE"))) {
            //elseif((D1-2新增员工身份人员.验证码 值不等于空  and M1-检测验证码是否有效.是否有效 等于 否))  615

//异常结束 988
            throw new BizException("C00006", "对不起，验证码错误！", false);
        }
        AddStaffBeginMemberRespDto retData = new AddStaffBeginMemberRespDto();
        if (string_11 != null) {
            retData.setInductionRecordId(string_11);//SimpleFieldAssign//sourceId:66691_1
        }
        if (users_1 != null) {
            retData.setUserId(users_1.getUserId());//SimpleFieldAssign//sourceId:66678_1
        }
        if (string_1 != null) {
            retData.setUserId(string_1);//SimpleFieldAssign//sourceId:66678_1
        }
        if (string_7 != null) {
            retData.setOriginalRoleMemberId(string_7);//SimpleFieldAssign//sourceId:66679_1
        }
        if (string_5 != null) {
            retData.setMemberId(string_5);//SimpleFieldAssign//sourceId:66681_1
        }
        if (sceneRole_1 != null) {
            retData.setRoleId(sceneRole_1.getRoleId());//SimpleFieldAssign//sourceId:66682_1
        }
        if (string_3 != null) {
            retData.setPersonalDataId(string_3);//SimpleFieldAssign//sourceId:66683_1
        }
        if (userinfo_3 != null) {
            retData.setPersonalDataId(userinfo_3.getPersonalDataId());//SimpleFieldAssign//sourceId:66683_1
        }
        if (string_9 != null) {
            retData.setOriginalStafInfoId(string_9);//SimpleFieldAssign//sourceId:66684_1
        }


        return retData;
    }

    /**
     * D1-新增空间管理员角色人员（平台）[972]
     * gen by moon at 1/24/2024, 3:47:48 AM
     */
    @Trace(operationName = "D1-新增空间管理员角色人员（平台）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AddAdminRoleRelRespDto addAdminRoleRel(AddAdminRoleRelReqDto reqDto) {


        String string_11 = null;
        QueryReceiveFieldDetailRespDto receptionServiceRes_1 = null;
        if ((reqDto != null && reqDto.getVerificationCode() != null)) {
            //if(D1-新增空间管理员角色人员（平台）.验证码 不等于空 )  442

//ModelCode: checkCaptchaValid
            CheckCaptchaValidRespDto checkCaptchaValidRes = null;
            CheckCaptchaValidReqDto checkCaptchaValidReq = new CheckCaptchaValidReqDto();
            if (reqDto != null) {
                checkCaptchaValidReq.setVerificationCode(reqDto.getVerificationCode());//SimpleFieldAssign//sourceId:41301_1_445
            }

            /*M-检测验证码是否有效（特殊方法）[1421]  用于检测用户前端录入验证码是否有效 */

            checkCaptchaValidRes = nbMember.checkCaptchaValid(checkCaptchaValidReq);


            if ((checkCaptchaValidRes != null && checkCaptchaValidRes.getIsInvalid() != null && checkCaptchaValidRes.getIsInvalid().equals("TRUE"))) {
                //if(M1-检测验证码是否有效.是否有效 等于 是)  446

                JudgeAddPerfectStaffUsableComRespDto judgeAddPerfectStaffUsableComRespDto = null;
                JudgeAddPerfectStaffUsableComReqDto judgeAddPerfectStaffUsableComReqDto = new JudgeAddPerfectStaffUsableComReqDto();
                judgeAddPerfectStaffUsableComReqDto.setRoleCode("TENANT_ORG_ADMIN");//CUSTOM_CONVENTION//sourceId:213949_1_13311
                judgeAddPerfectStaffUsableComReqDto.setPrivacyCode("TENANT_ORG_POWER_ADMIN");//CUSTOM_CONVENTION//sourceId:213950_1_13311
                if (reqDto != null) {
                    judgeAddPerfectStaffUsableComReqDto.setUserName(reqDto.getUserName());//SimpleFieldAssign//sourceId:213944_1_13311
                    judgeAddPerfectStaffUsableComReqDto.setRoleMemberCode(reqDto.getRoleMemberCode());//SimpleFieldAssign//sourceId:213945_1_13311
                }

                /*D1判断注册完善员工操作可用(公共)[4015]   */
                Assert.isNull(judgeAddPerfectStaffUsableComReqDto.getRoleMemberCode(), "D1-新增空间管理员角色人员（平台）-D1判断注册完善员工操作可用(公共)-身份人员编号不能为空", false);
                Assert.isNull(judgeAddPerfectStaffUsableComReqDto.getRoleCode(), "D1-新增空间管理员角色人员（平台）-D1判断注册完善员工操作可用(公共)-角色标识不能为空", false);
                Assert.isNull(judgeAddPerfectStaffUsableComReqDto.getPrivacyCode(), "D1-新增空间管理员角色人员（平台）-D1判断注册完善员工操作可用(公共)-权限标识不能为空", false);
                judgeAddPerfectStaffUsableComRespDto = judgeAddPerfectStaffUsableCom(judgeAddPerfectStaffUsableComReqDto)/*vcase invoke 同服务,同domain*/;
                Assert.isTrue(judgeAddPerfectStaffUsableComRespDto == null || judgeAddPerfectStaffUsableComRespDto.getOutputNum() == null, "找不到数据，系统异常", false);


                Users users = null;
                QueryUserDetailReq queryUserDetailReq = new QueryUserDetailReq();
                if (reqDto != null) {
                    queryUserDetailReq.setPhone(reqDto.getPhone());//SimpleFieldAssign//sourceId:20424_1_449
                }

                /*1-2-01查询个人账号详情[286]  通过手机号进行账号查询，无就结束查询，执行下一步注册个人账号；如果有账号执行下一步查询；  */
                Assert.isNull(queryUserDetailReq.getPhone(), "D1-新增空间管理员角色人员（平台）-1-2-01查询个人账号详情-绑定手机不能为空", false);
                users = mUsersService.queryUserDetail(queryUserDetailReq)/*vcase invoke 本地 method 方法调用;*/;


                if ((users == null)) {
                    //if(1-2-01查询个人账号详情.出参 等于空 )  450

                    String string = null;
                    Users users_2 = new Users();
                    users_2.setPassByEmail("FALSE");//sourceId:20440_1_453
                    users_2.setDevName(CommonFunctionHelper.getEquipMent());//GET_EQUIPMENT//sourceId:43818_1_453
                    users_2.setInviteUserId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecUserId());//CURRENT_USERID//sourceId:20454_1_453
                    if (reqDto != null) {
                        users_2.setUserName(reqDto.getUserName());//SimpleFieldAssign//sourceId:43816_1_453
                        users_2.setPassword(reqDto.getPassword());//SimpleFieldAssign//sourceId:43904_1_453
                        users_2.setIsPasswordExit(reqDto.getIsPasswordExit());//SimpleFieldAssign//sourceId:43817_1_453
                        users_2.setEmail(reqDto.getEmail());//SimpleFieldAssign//sourceId:43829_1_453
                        users_2.setPhone(reqDto.getPhone());//SimpleFieldAssign//sourceId:20441_1_453
                        users_2.setPassByPhone(reqDto.getPassByPhone());//SimpleFieldAssign//sourceId:20442_1_453
                        users_2.setIsUserInfoDone(reqDto.getIsUserInfoDone());//SimpleFieldAssign//sourceId:43811_1_453
                        users_2.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:20455_1_453
                        users_2.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:20456_1_453
                        users_2.setSenceId(reqDto.getSenceId());//SimpleFieldAssign//sourceId:43813_1_453
                    }

                    /*1-2-01新增个人账号[45] 前面判断没有个人账号，执行此步注册账号  */
                    Assert.isNull(users_2.getPassword(), "D1-新增空间管理员角色人员（平台）-1-2-01新增个人账号-密码不能为空", false);
                    Assert.isNull(users_2.getIsPasswordExit(), "D1-新增空间管理员角色人员（平台）-1-2-01新增个人账号-密码是否为空不能为空", false);
                    Assert.isNull(users_2.getPassByEmail(), "D1-新增空间管理员角色人员（平台）-1-2-01新增个人账号-邮箱激活状态不能为空", false);
                    Assert.isNull(users_2.getPhone(), "D1-新增空间管理员角色人员（平台）-1-2-01新增个人账号-绑定手机不能为空", false);
                    Assert.isNull(users_2.getPassByPhone(), "D1-新增空间管理员角色人员（平台）-1-2-01新增个人账号-手机激活状态不能为空", false);
                    Assert.isNull(users_2.getIsUserInfoDone(), "D1-新增空间管理员角色人员（平台）-1-2-01新增个人账号-个人资料是否完善不能为空", false);
                    Assert.isNull(users_2.getInviteUserId(), "D1-新增空间管理员角色人员（平台）-1-2-01新增个人账号-邀请人账号不能为空", false);
                    Assert.isNull(users_2.getSpaceId(), "D1-新增空间管理员角色人员（平台）-1-2-01新增个人账号-创建于空间ID不能为空", false);
                    Assert.isNull(users_2.getAppId(), "D1-新增空间管理员角色人员（平台）-1-2-01新增个人账号-创建于联盟应用ID不能为空", false);
                    Assert.isNull(users_2.getSenceId(), "D1-新增空间管理员角色人员（平台）-1-2-01新增个人账号-归属于场景ID不能为空", false);
                    string = mUsersService.addUser(users_2)/*vcase invoke 本地 method 方法调用;*/;


                    String string_2 = null;
                    if (string != null) {
                        Userinfo userinfo = new Userinfo();
                        if (string != null) {
                            userinfo.setUserId(string);//SimpleFieldAssign//sourceId:20584_1_454
                        }
                        if (reqDto != null) {
                            userinfo.setIdCardName(reqDto.getIdCardName());//SimpleFieldAssign//sourceId:20585_1_454
                            userinfo.setFirstLetter(CommonFunctionHelper.firstChar(reqDto.getIdCardName()));//FIRST_CHAR //todo 字段备注首位字母来源为空,请设置!!;//sourceId:56813_1_454
                            userinfo.setUserFace(reqDto.getUserFace());//SimpleFieldAssign//sourceId:20587_1_454
                            userinfo.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:20592_1_454
                            userinfo.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:20593_1_454
                        }

                        /*1-2-02新增个人资料[49] 根据上一步入参的个人账号ID，生成个人资料。  */
                        Assert.isNull(userinfo.getUserId(), "D1-新增空间管理员角色人员（平台）-1-2-02新增个人资料-账号不能为空", false);
                        Assert.isNull(userinfo.getIdCardName(), "D1-新增空间管理员角色人员（平台）-1-2-02新增个人资料-真实姓名不能为空", false);
                        Assert.isNull(userinfo.getFirstLetter(), "D1-新增空间管理员角色人员（平台）-1-2-02新增个人资料-备注首位字母不能为空", false);
                        Assert.isNull(userinfo.getUserFace(), "D1-新增空间管理员角色人员（平台）-1-2-02新增个人资料-真实头像不能为空", false);
                        Assert.isNull(userinfo.getSpaceId(), "D1-新增空间管理员角色人员（平台）-1-2-02新增个人资料-创建于空间ID不能为空", false);
                        Assert.isNull(userinfo.getAppId(), "D1-新增空间管理员角色人员（平台）-1-2-02新增个人资料-归属应用ID不能为空", false);
                        string_2 = mUserinfoService.addUserinfo(userinfo)/*vcase invoke 本地 method 方法调用;*/;


                    }
                    String string_4 = null;
                    if (string != null) {
                        SpaceMember spaceMember = new SpaceMember();
                        if (string != null) {
                            spaceMember.setUserId(string);//SimpleFieldAssign//sourceId:20460_1_455
                        }
                        if (reqDto != null) {
                            spaceMember.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:20461_1_455
                            spaceMember.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:20462_1_455
                        }

                        /*1-2-05新增空间成员关系[61] 上一步注册个人账号成功出参后，本步生成成员ID  */
                        Assert.isNull(spaceMember.getUserId(), "D1-新增空间管理员角色人员（平台）-1-2-05新增空间成员关系-成员个人账号不能为空", false);
                        Assert.isNull(spaceMember.getSpaceId(), "D1-新增空间管理员角色人员（平台）-1-2-05新增空间成员关系-创建于空间ID不能为空", false);
                        Assert.isNull(spaceMember.getAppId(), "D1-新增空间管理员角色人员（平台）-1-2-05新增空间成员关系-创建于联盟应用ID不能为空", false);
                        string_4 = mSpaceMemberService.addMember(spaceMember)/*vcase invoke 本地 method 方法调用;*/;


                    }
                    SceneRole sceneRole = null;
                    QueryRoleDetailReq queryRoleDetailReq = new QueryRoleDetailReq();
                    queryRoleDetailReq.setRoleCode("STAFF");//CUSTOM_CONVENTION//sourceId:29850_1_456
                    queryRoleDetailReq.setIsIdentity("TRUE");//sourceId:29851_1_456
                    queryRoleDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:29852_1_456
                    queryRoleDetailReq.setIsArchive("FALSE");//sourceId:29853_1_456

                    /*1-2-08查询角色详情（查员工身份角色ID）[170]   */
                    Assert.isNull(queryRoleDetailReq.getRoleCode(), "D1-新增空间管理员角色人员（平台）-1-2-08查询角色详情（查员工身份角色ID）-角色标识不能为空", false);
                    Assert.isNull(queryRoleDetailReq.getIsIdentity(), "D1-新增空间管理员角色人员（平台）-1-2-08查询角色详情（查员工身份角色ID）-是否身份角色不能为空", false);
                    Assert.isNull(queryRoleDetailReq.getSubjectLifeCycle(), "D1-新增空间管理员角色人员（平台）-1-2-08查询角色详情（查员工身份角色ID）-主体生命周期不能为空", false);
                    Assert.isNull(queryRoleDetailReq.getIsArchive(), "D1-新增空间管理员角色人员（平台）-1-2-08查询角色详情（查员工身份角色ID）-是否存档不能为空", false);
                    sceneRole = mSceneRoleService.queryRoleDetail(queryRoleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


                    String string_6 = null;
                    if (string_4 != null && string != null && sceneRole != null) {
                        OriginalRoleMember originalRoleMember = new OriginalRoleMember();
                        originalRoleMember.setSource("SET_WITHIN_ORG");//sourceId:20467_1_457
                        originalRoleMember.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:20469_1_457
                        if (string_4 != null) {
                            originalRoleMember.setMemberId(string_4);//SimpleFieldAssign//sourceId:20464_1_457
                        }
                        if (string != null) {
                            originalRoleMember.setUserId(string);//SimpleFieldAssign//sourceId:23787_1_457
                        }
                        if (sceneRole != null) {
                            originalRoleMember.setRoleId(sceneRole.getRoleId());//SimpleFieldAssign//sourceId:23814_1_457
                            originalRoleMember.setRoleCode(sceneRole.getRoleCode());//SimpleFieldAssign//sourceId:20522_1_457
                        }
                        if (reqDto != null) {
                            originalRoleMember.setFirstLetter(CommonFunctionHelper.firstChar(reqDto.getIdCardName()));//FIRST_CHAR //todo 字段备注首位字母来源为空,请设置!!;//sourceId:20466_1_457
                            originalRoleMember.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:20470_1_457
                            originalRoleMember.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:20471_1_457
                        }

                        /*1-2-09新增身份人员[77] 获取上一步出参的成员ID，还有前端固化的角色编码STAFF，生成员工原始角色身份的成员关系ID（例如员工等）。  */
                        Assert.isNull(originalRoleMember.getMemberId(), "D1-新增空间管理员角色人员（平台）-1-2-09新增身份人员-成员ID不能为空", false);
                        Assert.isNull(originalRoleMember.getUserId(), "D1-新增空间管理员角色人员（平台）-1-2-09新增身份人员-账号ID不能为空", false);
                        Assert.isNull(originalRoleMember.getRoleId(), "D1-新增空间管理员角色人员（平台）-1-2-09新增身份人员-身份角色ID不能为空", false);
                        Assert.isNull(originalRoleMember.getRoleCode(), "D1-新增空间管理员角色人员（平台）-1-2-09新增身份人员-身份角色编码不能为空", false);
                        Assert.isNull(originalRoleMember.getFirstLetter(), "D1-新增空间管理员角色人员（平台）-1-2-09新增身份人员-备注首位字母不能为空", false);
                        Assert.isNull(originalRoleMember.getSource(), "D1-新增空间管理员角色人员（平台）-1-2-09新增身份人员-关系建立来源不能为空", false);
                        Assert.isNull(originalRoleMember.getSubjectLifeCycle(), "D1-新增空间管理员角色人员（平台）-1-2-09新增身份人员-主体生命周期不能为空", false);
                        Assert.isNull(originalRoleMember.getSpaceId(), "D1-新增空间管理员角色人员（平台）-1-2-09新增身份人员-创建于空间ID不能为空", false);
                        Assert.isNull(originalRoleMember.getAppId(), "D1-新增空间管理员角色人员（平台）-1-2-09新增身份人员-创建于联盟应用ID不能为空", false);
                        string_6 = mOriginalRoleMemberService.addBeginMember(originalRoleMember)/*vcase invoke 本地 method 方法调用;*/;


                    }
                    String string_8 = null;
                    if (string_6 != null) {
                        OriginalRoleMemberInfo originalRoleMemberInfo = new OriginalRoleMemberInfo();
                        if (string_6 != null) {
                            originalRoleMemberInfo.setOriginalRoleMemberId(string_6);//SimpleFieldAssign//sourceId:20473_1_458
                        }
                        if (reqDto != null) {
                            originalRoleMemberInfo.setRoleMemberCode(reqDto.getRoleMemberCode());//SimpleFieldAssign//sourceId:20474_1_458
                            originalRoleMemberInfo.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:20479_1_458
                            originalRoleMemberInfo.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:20480_1_458
                        }

                        /*1-2-10新增身份人员资料[113] 获取上一步出参的原始角色成员关系ID，创建原始角色成员关系资料（例如员工资料）；  */
                        Assert.isNull(originalRoleMemberInfo.getOriginalRoleMemberId(), "D1-新增空间管理员角色人员（平台）-1-2-10新增身份人员资料-身份人员ID不能为空", false);
                        Assert.isNull(originalRoleMemberInfo.getRoleMemberCode(), "D1-新增空间管理员角色人员（平台）-1-2-10新增身份人员资料-身份人员编号不能为空", false);
                        Assert.isNull(originalRoleMemberInfo.getSpaceId(), "D1-新增空间管理员角色人员（平台）-1-2-10新增身份人员资料-创建于空间ID不能为空", false);
                        Assert.isNull(originalRoleMemberInfo.getAppId(), "D1-新增空间管理员角色人员（平台）-1-2-10新增身份人员资料-创建于联盟应用ID不能为空", false);
                        string_8 = mOriginalRoleMemberInfoService.addBeginMembInfo(originalRoleMemberInfo)/*vcase invoke 本地 method 方法调用;*/;


                    }
                    SceneRole sceneRole_2 = null;
                    QueryRoleDetailReq queryRoleDetailReq_1 = new QueryRoleDetailReq();
                    queryRoleDetailReq_1.setRoleCode("ADMIN");//CUSTOM_CONVENTION//sourceId:29885_1_459
                    queryRoleDetailReq_1.setIsIdentity("FALSE");//sourceId:29886_1_459
                    queryRoleDetailReq_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:29887_1_459

                    /*1-2-08查询角色详情（查管理员普通角色ID）[170]   */
                    Assert.isNull(queryRoleDetailReq_1.getRoleCode(), "D1-新增空间管理员角色人员（平台）-1-2-08查询角色详情（查管理员普通角色ID）-角色标识不能为空", false);
                    Assert.isNull(queryRoleDetailReq_1.getIsIdentity(), "D1-新增空间管理员角色人员（平台）-1-2-08查询角色详情（查管理员普通角色ID）-是否身份角色不能为空", false);
                    Assert.isNull(queryRoleDetailReq_1.getSubjectLifeCycle(), "D1-新增空间管理员角色人员（平台）-1-2-08查询角色详情（查管理员普通角色ID）-主体生命周期不能为空", false);
                    sceneRole_2 = mSceneRoleService.queryRoleDetail(queryRoleDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;


                    SceneRole sceneRole_4 = null;
                    QueryRoleDetailReq queryRoleDetailReq_2 = new QueryRoleDetailReq();
                    queryRoleDetailReq_2.setRoleCode("ORG_ADMIN");//CUSTOM_CONVENTION//sourceId:255943_1_14519
                    queryRoleDetailReq_2.setIsIdentity("FALSE");//sourceId:255944_1_14519
                    queryRoleDetailReq_2.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:255945_1_14519

                    /*1-2-08查询角色详情（查组织架构管理员业务角色ID）[170]   */
                    Assert.isNull(queryRoleDetailReq_2.getRoleCode(), "D1-新增空间管理员角色人员（平台）-1-2-08查询角色详情（查组织架构管理员业务角色ID）-角色标识不能为空", false);
                    Assert.isNull(queryRoleDetailReq_2.getIsIdentity(), "D1-新增空间管理员角色人员（平台）-1-2-08查询角色详情（查组织架构管理员业务角色ID）-是否身份角色不能为空", false);
                    Assert.isNull(queryRoleDetailReq_2.getSubjectLifeCycle(), "D1-新增空间管理员角色人员（平台）-1-2-08查询角色详情（查组织架构管理员业务角色ID）-主体生命周期不能为空", false);
                    sceneRole_4 = mSceneRoleService.queryRoleDetail(queryRoleDetailReq_2)/*vcase invoke 本地 method 方法调用;*/;
                    Assert.isTrue(sceneRole_4 == null || sceneRole_4.getRoleId() == null, "找不到数据，系统异常", false);


                    String string_10 = null;
                    if (string_6 != null && sceneRole_2 != null && string != null) {
                        RoleMember roleMember = new RoleMember();
                        roleMember.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:20485_1_460
                        if (string_6 != null) {
                            roleMember.setOriginalRoleMemberId(string_6);//SimpleFieldAssign//sourceId:20481_1_460
                        }
                        if (sceneRole_2 != null) {
                            roleMember.setRoleId(sceneRole_2.getRoleId());//SimpleFieldAssign//sourceId:23813_1_460
                            roleMember.setRoleCode(sceneRole_2.getRoleCode());//SimpleFieldAssign//sourceId:20524_1_460
                        }
                        if (string != null) {
                            roleMember.setUserId(string);//SimpleFieldAssign//sourceId:53750_1_460
                        }
                        if (reqDto != null) {
                            roleMember.setFirstLetter(CommonFunctionHelper.firstChar(reqDto.getIdCardName()));//FIRST_CHAR //todo 字段备注首位字母来源为空,请设置!!;//sourceId:20483_1_460
                            roleMember.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:20486_1_460
                            roleMember.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:20487_1_460
                        }

                        /*1-2-13新增角色人员（空间管理员及组织架构管理员）[331] 根据前面出参原始角色成员关系ID，还有前端固化的角色编码ADMIN，生成非原始角色成员关系ID（管理员等）  */
                        Assert.isNull(roleMember.getOriginalRoleMemberId(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-身份人员ID不能为空", false);
                        Assert.isNull(roleMember.getRoleId(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-角色ID不能为空", false);
                        Assert.isNull(roleMember.getUserId(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-账号ID不能为空", false);
                        Assert.isNull(roleMember.getRoleCode(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-角色标识不能为空", false);
                        Assert.isNull(roleMember.getFirstLetter(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-备注首位字母不能为空", false);
                        Assert.isNull(roleMember.getSubjectLifeCycle(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-主体生命周期不能为空", false);
                        Assert.isNull(roleMember.getSpaceId(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-创建于空间ID不能为空", false);
                        Assert.isNull(roleMember.getAppId(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-创建于联盟应用ID不能为空", false);
                        string_10 = mRoleMemberService.addRoleRel(roleMember)/*vcase invoke 本地 method 方法调用;*/;


                        string_11 = string_10;
                    }
                    String string_12 = null;
                    if (string_6 != null && string != null && sceneRole_4 != null) {
                        RoleMember roleMember_1 = new RoleMember();
                        roleMember_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:20485_1_14520
                        if (string_6 != null) {
                            roleMember_1.setOriginalRoleMemberId(string_6);//SimpleFieldAssign//sourceId:20481_1_14520
                        }
                        if (string != null) {
                            roleMember_1.setUserId(string);//SimpleFieldAssign//sourceId:53750_1_14520
                        }
                        if (sceneRole_4 != null) {
                            roleMember_1.setRoleId(sceneRole_4.getRoleId());//SimpleFieldAssign//sourceId:23813_1_14520
                            roleMember_1.setRoleCode(sceneRole_4.getRoleCode());//SimpleFieldAssign//sourceId:20524_1_14520
                        }
                        if (reqDto != null) {
                            roleMember_1.setFirstLetter(CommonFunctionHelper.firstChar(reqDto.getIdCardName()));//FIRST_CHAR //todo 字段备注首位字母来源为空,请设置!!;//sourceId:20483_1_14520
                            roleMember_1.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:20486_1_14520
                            roleMember_1.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:20487_1_14520
                        }

                        /*1-2-13新增角色人员（空间管理员及组织架构管理员）[331] 根据前面出参原始角色成员关系ID，还有前端固化的角色编码ADMIN，生成非原始角色成员关系ID（管理员等）  */
                        Assert.isNull(roleMember_1.getOriginalRoleMemberId(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-身份人员ID不能为空", false);
                        Assert.isNull(roleMember_1.getUserId(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-账号ID不能为空", false);
                        Assert.isNull(roleMember_1.getRoleId(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-角色ID不能为空", false);
                        Assert.isNull(roleMember_1.getRoleCode(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-角色标识不能为空", false);
                        Assert.isNull(roleMember_1.getFirstLetter(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-备注首位字母不能为空", false);
                        Assert.isNull(roleMember_1.getSubjectLifeCycle(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-主体生命周期不能为空", false);
                        Assert.isNull(roleMember_1.getSpaceId(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-创建于空间ID不能为空", false);
                        Assert.isNull(roleMember_1.getAppId(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-创建于联盟应用ID不能为空", false);
                        string_12 = mRoleMemberService.addRoleRel(roleMember_1)/*vcase invoke 本地 method 方法调用;*/;


                        string_11 = string_12;
                    }
                    Organization organization = null;
                    QueryOrgDetailReq queryOrgDetailReq = new QueryOrgDetailReq();
                    queryOrgDetailReq.setIsHighOrg("TRUE");//sourceId:41177_1_461
                    if (reqDto != null) {
                        queryOrgDetailReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:41178_1_461
                    }

                    /*1-3-12查询组织详情[201]   */
                    Assert.isNull(queryOrgDetailReq.getIsHighOrg(), "D1-新增空间管理员角色人员（平台）-1-3-12查询组织详情-是否最高组织不能为空", false);
                    organization = mOrganizationService.queryOrgDetail(queryOrgDetailReq)/*vcase invoke 本地 method 方法调用;*/;


                    QueryItemMatchResultToAnswerDetailComRespDto queryItemMatchResultToAnswerDetailComRespDto = null;
                    QueryItemMatchResultToAnswerDetailComReqDto queryItemMatchResultToAnswerDetailComReqDto = new QueryItemMatchResultToAnswerDetailComReqDto();
                    queryItemMatchResultToAnswerDetailComReqDto.setConfItemCode("ORG_STRUCTURE_MODEL");//CUSTOM_CONVENTION//sourceId:105095_1_5660
                    queryItemMatchResultToAnswerDetailComReqDto.setResultAspObjType("TENANT_SPACE");//sourceId:105096_1_5660
                    queryItemMatchResultToAnswerDetailComReqDto.setResultAspObjId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:105097_1_5660
                    queryItemMatchResultToAnswerDetailComReqDto.setIsInitialScheme("TRUE");//sourceId:308465_1_5660
                    queryItemMatchResultToAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:308466_1_5660

                    /*D2-3查询配置项匹配结果转答案(公共)[3094]   */
                    Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto.getConfItemCode(), "D1-新增空间管理员角色人员（平台）-D2-3查询配置项匹配结果转答案(公共)-配置项标识不能为空", false);
                    Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto.getResultAspObjType(), "D1-新增空间管理员角色人员（平台）-D2-3查询配置项匹配结果转答案(公共)-开通对象类型编码不能为空", false);
                    Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto.getResultAspObjId(), "D1-新增空间管理员角色人员（平台）-D2-3查询配置项匹配结果转答案(公共)-开通对象ID不能为空", false);
                    Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto.getIsInitialScheme(), "D1-新增空间管理员角色人员（平台）-D2-3查询配置项匹配结果转答案(公共)-是否初始方案答案不能为空", false);
                    Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto.getIsPlatData(), "D1-新增空间管理员角色人员（平台）-D2-3查询配置项匹配结果转答案(公共)-是否标准答案不能为空", false);
                    queryItemMatchResultToAnswerDetailComRespDto = confSchemeService.queryItemMatchResultToAnswerDetailCom(queryItemMatchResultToAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//ModelCode: receptionService
                    QueryReceiveFieldDetailRespDto receptionServiceRes = null;
                    if (string_6 != null && string != null) {
                        QueryReceiveFieldDetailReqDto receptionServiceReq = new QueryReceiveFieldDetailReqDto();
                        if (string_6 != null) {
                            receptionServiceReq.setOriginalRoleMemberId(string_6);//SimpleFieldAssign//sourceId:1499886_1_60082
                        }
                        if (string != null) {
                            receptionServiceReq.setUserId(string);//SimpleFieldAssign//sourceId:1499887_1_60082
                        }

                        /*约定出参：身份人员及账号[3715]  用于特殊方法接收上游入参。 */
                        Assert.isNull(receptionServiceReq.getOriginalRoleMemberId(), "D1-新增空间管理员角色人员（平台）-约定出参：身份人员及账号-身份人员ID不能为空", false);
                        Assert.isNull(receptionServiceReq.getUserId(), "D1-新增空间管理员角色人员（平台）-约定出参：身份人员及账号-账号不能为空", false);
                        receptionServiceRes = nbMember.queryReceiveFieldDetail(receptionServiceReq);


                        receptionServiceRes_1 = receptionServiceRes;
                    }
                    if ((queryItemMatchResultToAnswerDetailComRespDto != null && queryItemMatchResultToAnswerDetailComRespDto.getOrgStructureModel() != null)) {
                        //if(D2-3查询配置项匹配结果转答案(公共).空间组织架构模式 值不等于空 )  462

                        String string_13 = null;
                        if (organization != null && string_6 != null && string != null) {
                            InductionRecord inductionRecord = new InductionRecord();
                            inductionRecord.setInductionUnitTypeCode("ORG");//sourceId:41124_1_465
                            inductionRecord.setPositionType("MEMBER");//sourceId:63942_1_465
                            inductionRecord.setIsMainInduction("TRUE");//sourceId:41132_1_465
                            inductionRecord.setOrderNumber(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:285160_1_465
                            inductionRecord.setIsCustomPosition("TRUE");//sourceId:41133_1_465
                            inductionRecord.setPositionIdName("成员");//CUSTOM_CONVENTION//sourceId:41137_1_465
                            inductionRecord.setInductionStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:41157_1_465
                            inductionRecord.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:41200_1_465
                            inductionRecord.setIsUpdate("FALSE");//sourceId:281849_1_465
                            inductionRecord.setUpdateStatus("UNCHANGED");//sourceId:281850_1_465
                            inductionRecord.setIsEditing("FALSE");//sourceId:41201_1_465
                            inductionRecord.setIsDirector("FALSE");//sourceId:246856_1_465
                            if (organization != null) {
                                inductionRecord.setEntityId(organization.getOrganizationId());//SimpleFieldAssign//sourceId:41125_1_465
                                inductionRecord.setOrganizationId(organization.getOrganizationId());//SimpleFieldAssign//sourceId:41128_1_465
                                inductionRecord.setOrganizationName(organization.getOrganizationName());//SimpleFieldAssign//sourceId:161495_1_465
                            }
                            if (string_6 != null) {
                                inductionRecord.setOriginalRoleMemberId(string_6);//SimpleFieldAssign//sourceId:41126_1_465
                            }
                            if (string != null) {
                                inductionRecord.setUserId(string);//SimpleFieldAssign//sourceId:41127_1_465
                            }
                            if (reqDto != null) {
                                inductionRecord.setFirstLetter(CommonFunctionHelper.firstChar(reqDto.getIdCardName()));//FIRST_CHAR //todo 字段备注首位字母来源为空,请设置!!;//sourceId:41130_1_465
                                inductionRecord.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:50362_1_465
                                inductionRecord.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:50363_1_465
                            }

                            /*1-3-13新增就职记录[162]   */
                            Assert.isNull(inductionRecord.getInductionUnitTypeCode(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-就职单位类型实例不能为空", false);
                            Assert.isNull(inductionRecord.getEntityId(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-就职单位对象实例ID不能为空", false);
                            Assert.isNull(inductionRecord.getOriginalRoleMemberId(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-身份人员ID不能为空", false);
                            Assert.isNull(inductionRecord.getUserId(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-个人账号ID不能为空", false);
                            Assert.isNull(inductionRecord.getFirstLetter(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-备注首位字母不能为空", false);
                            Assert.isNull(inductionRecord.getOrganizationId(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-组织ID不能为空", false);
                            Assert.isNull(inductionRecord.getOrganizationName(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-冗余组织名称不能为空", false);
                            Assert.isNull(inductionRecord.getPositionType(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-职务性质不能为空", false);
                            Assert.isNull(inductionRecord.getIsMainInduction(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-是否主岗不能为空", false);
                            Assert.isNull(inductionRecord.getOrderNumber(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-排序不能为空", false);
                            Assert.isNull(inductionRecord.getIsCustomPosition(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-是否自定义职务不能为空", false);
                            Assert.isNull(inductionRecord.getPositionIdName(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-必选冗余职务名称不能为空", false);
                            Assert.isNull(inductionRecord.getSubjectLifeCycle(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-主体生命周期不能为空", false);
                            Assert.isNull(inductionRecord.getIsUpdate(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-批次下是否更新不能为空", false);
                            Assert.isNull(inductionRecord.getUpdateStatus(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-批次下更新状态不能为空", false);
                            Assert.isNull(inductionRecord.getIsEditing(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-是否未来不能为空", false);
                            Assert.isNull(inductionRecord.getIsDirector(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-是否主管不能为空", false);
                            Assert.isNull(inductionRecord.getSpaceId(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-创建于空间ID不能为空", false);
                            Assert.isNull(inductionRecord.getAppId(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-创建于联盟应用ID不能为空", false);
                            string_13 = mInductionRecordService.addInductionRecord(inductionRecord)/*vcase invoke 本地 method 方法调用;*/;


                        }
//processBranchName:正常结束 ,processBranchId:466

                    } else {
                        //else  700

//processBranchName:正常结束 ,processBranchId:702

                    }
                } else {
                    //else  451

                    JudgeAddPerfectStaffUsableComRespDto judgeAddPerfectStaffUsableComRespDto_2 = null;
                    JudgeAddPerfectStaffUsableComReqDto judgeAddPerfectStaffUsableComReqDto_1 = new JudgeAddPerfectStaffUsableComReqDto();
                    judgeAddPerfectStaffUsableComReqDto_1.setRoleCode("TENANT_ORG_ADMIN");//CUSTOM_CONVENTION//sourceId:213949_1_13312
                    judgeAddPerfectStaffUsableComReqDto_1.setPrivacyCode("TENANT_ORG_POWER_ADMIN");//CUSTOM_CONVENTION//sourceId:213950_1_13312
                    if (reqDto != null) {
                        judgeAddPerfectStaffUsableComReqDto_1.setUserName(reqDto.getUserName());//SimpleFieldAssign//sourceId:213944_1_13312
                        judgeAddPerfectStaffUsableComReqDto_1.setRoleMemberCode(reqDto.getRoleMemberCode());//SimpleFieldAssign//sourceId:213945_1_13312
                    }

                    /*D1判断注册完善员工操作可用(公共)[4015]   */
                    Assert.isNull(judgeAddPerfectStaffUsableComReqDto_1.getRoleMemberCode(), "D1-新增空间管理员角色人员（平台）-D1判断注册完善员工操作可用(公共)-身份人员编号不能为空", false);
                    Assert.isNull(judgeAddPerfectStaffUsableComReqDto_1.getRoleCode(), "D1-新增空间管理员角色人员（平台）-D1判断注册完善员工操作可用(公共)-角色标识不能为空", false);
                    Assert.isNull(judgeAddPerfectStaffUsableComReqDto_1.getPrivacyCode(), "D1-新增空间管理员角色人员（平台）-D1判断注册完善员工操作可用(公共)-权限标识不能为空", false);
                    judgeAddPerfectStaffUsableComRespDto_2 = judgeAddPerfectStaffUsableCom(judgeAddPerfectStaffUsableComReqDto_1)/*vcase invoke 同服务,同domain*/;
                    Assert.isTrue(judgeAddPerfectStaffUsableComRespDto_2 == null || judgeAddPerfectStaffUsableComRespDto_2.getOutputNum() == null, "找不到数据，系统异常", false);


                    SpaceMember spaceMember_1 = null;
                    if (users != null) {
                        QueryMemberDetailReq queryMemberDetailReq = new QueryMemberDetailReq();
                        if (users != null) {
                            queryMemberDetailReq.setUserId(users.getUserId());//SimpleFieldAssign//sourceId:20430_1_452
                        }
                        if (reqDto != null) {
                            queryMemberDetailReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:20520_1_452
                        }

                        /*1-2-05查询空间成员关系详情[167] 通过上一步出参的个人账号查询成员ID，无就结束查询，执行下一步生成成员ID，；如果有成员ID就出参（表示已经是成员，前端报错告知有此人，不可设成员）  */
                        Assert.isNull(queryMemberDetailReq.getUserId(), "D1-新增空间管理员角色人员（平台）-1-2-05查询空间成员关系详情-成员个人账号不能为空", false);
                        Assert.isNull(queryMemberDetailReq.getSpaceId(), "D1-新增空间管理员角色人员（平台）-1-2-05查询空间成员关系详情-创建于空间ID不能为空", false);
                        spaceMember_1 = mSpaceMemberService.queryMemberDetail(queryMemberDetailReq)/*vcase invoke 本地 method 方法调用;*/;


                    }
                    if ((spaceMember_1 == null)) {
                        //if(1-2-05查询空间成员关系详情.出参 等于空 )  467

                        String string_15 = null;
                        if (users != null) {
                            SpaceMember spaceMember_3 = new SpaceMember();
                            if (users != null) {
                                spaceMember_3.setUserId(users.getUserId());//SimpleFieldAssign//sourceId:20460_1_470
                            }
                            if (reqDto != null) {
                                spaceMember_3.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:20461_1_470
                                spaceMember_3.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:20462_1_470
                            }

                            /*1-2-05新增空间成员关系[61] 上一步注册个人账号成功出参后，本步生成成员ID  */
                            Assert.isNull(spaceMember_3.getUserId(), "D1-新增空间管理员角色人员（平台）-1-2-05新增空间成员关系-成员个人账号不能为空", false);
                            Assert.isNull(spaceMember_3.getSpaceId(), "D1-新增空间管理员角色人员（平台）-1-2-05新增空间成员关系-创建于空间ID不能为空", false);
                            Assert.isNull(spaceMember_3.getAppId(), "D1-新增空间管理员角色人员（平台）-1-2-05新增空间成员关系-创建于联盟应用ID不能为空", false);
                            string_15 = mSpaceMemberService.addMember(spaceMember_3)/*vcase invoke 本地 method 方法调用;*/;


                        }
                        SceneRole sceneRole_6 = null;
                        QueryRoleDetailReq queryRoleDetailReq_3 = new QueryRoleDetailReq();
                        queryRoleDetailReq_3.setRoleCode("STAFF");//CUSTOM_CONVENTION//sourceId:29850_1_471
                        queryRoleDetailReq_3.setIsIdentity("TRUE");//sourceId:29851_1_471
                        queryRoleDetailReq_3.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:29852_1_471
                        queryRoleDetailReq_3.setIsArchive("FALSE");//sourceId:29853_1_471

                        /*1-2-08查询角色详情（查员工身份角色ID）[170]   */
                        Assert.isNull(queryRoleDetailReq_3.getRoleCode(), "D1-新增空间管理员角色人员（平台）-1-2-08查询角色详情（查员工身份角色ID）-角色标识不能为空", false);
                        Assert.isNull(queryRoleDetailReq_3.getIsIdentity(), "D1-新增空间管理员角色人员（平台）-1-2-08查询角色详情（查员工身份角色ID）-是否身份角色不能为空", false);
                        Assert.isNull(queryRoleDetailReq_3.getSubjectLifeCycle(), "D1-新增空间管理员角色人员（平台）-1-2-08查询角色详情（查员工身份角色ID）-主体生命周期不能为空", false);
                        Assert.isNull(queryRoleDetailReq_3.getIsArchive(), "D1-新增空间管理员角色人员（平台）-1-2-08查询角色详情（查员工身份角色ID）-是否存档不能为空", false);
                        sceneRole_6 = mSceneRoleService.queryRoleDetail(queryRoleDetailReq_3)/*vcase invoke 本地 method 方法调用;*/;


                        Userinfo userinfo_1 = null;
                        if (users != null) {
                            QueryUserinfoDetailReq queryUserinfoDetailReq = new QueryUserinfoDetailReq();
                            if (users != null) {
                                queryUserinfoDetailReq.setUserId(users.getUserId());//SimpleFieldAssign//sourceId:41863_1_726
                            }

                            /*1-2-02查询个人资料详情（查首字母）[155]   */
                            Assert.isNull(queryUserinfoDetailReq.getUserId(), "D1-新增空间管理员角色人员（平台）-1-2-02查询个人资料详情（查首字母）-账号不能为空", false);
                            userinfo_1 = mUserinfoService.queryUserinfoDetail(queryUserinfoDetailReq)/*vcase invoke 本地 method 方法调用;*/;


                        }
                        String string_16 = null;
                        if (string_15 != null && users != null && sceneRole_6 != null && userinfo_1 != null) {
                            OriginalRoleMember originalRoleMember_1 = new OriginalRoleMember();
                            originalRoleMember_1.setSource("SET_WITHIN_ORG");//sourceId:20467_1_727
                            originalRoleMember_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:20469_1_727
                            if (string_15 != null) {
                                originalRoleMember_1.setMemberId(string_15);//SimpleFieldAssign//sourceId:20464_1_727
                            }
                            if (users != null) {
                                originalRoleMember_1.setUserId(users.getUserId());//SimpleFieldAssign//sourceId:23787_1_727
                            }
                            if (sceneRole_6 != null) {
                                originalRoleMember_1.setRoleId(sceneRole_6.getRoleId());//SimpleFieldAssign//sourceId:23814_1_727
                                originalRoleMember_1.setRoleCode(sceneRole_6.getRoleCode());//SimpleFieldAssign//sourceId:20522_1_727
                            }
                            if (userinfo_1 != null) {
                                originalRoleMember_1.setFirstLetter(CommonFunctionHelper.firstChar(userinfo_1.getFirstLetter()));//FIRST_CHAR //todo 字段备注首位字母来源为空,请设置!!;//sourceId:20466_1_727
                            }
                            if (reqDto != null) {
                                originalRoleMember_1.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:20470_1_727
                                originalRoleMember_1.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:20471_1_727
                            }

                            /*1-2-09新增身份人员[77] 获取上一步出参的成员ID，还有前端固化的角色编码STAFF，生成员工原始角色身份的成员关系ID（例如员工等）。  */
                            Assert.isNull(originalRoleMember_1.getMemberId(), "D1-新增空间管理员角色人员（平台）-1-2-09新增身份人员-成员ID不能为空", false);
                            Assert.isNull(originalRoleMember_1.getUserId(), "D1-新增空间管理员角色人员（平台）-1-2-09新增身份人员-账号ID不能为空", false);
                            Assert.isNull(originalRoleMember_1.getRoleId(), "D1-新增空间管理员角色人员（平台）-1-2-09新增身份人员-身份角色ID不能为空", false);
                            Assert.isNull(originalRoleMember_1.getRoleCode(), "D1-新增空间管理员角色人员（平台）-1-2-09新增身份人员-身份角色编码不能为空", false);
                            Assert.isNull(originalRoleMember_1.getFirstLetter(), "D1-新增空间管理员角色人员（平台）-1-2-09新增身份人员-备注首位字母不能为空", false);
                            Assert.isNull(originalRoleMember_1.getSource(), "D1-新增空间管理员角色人员（平台）-1-2-09新增身份人员-关系建立来源不能为空", false);
                            Assert.isNull(originalRoleMember_1.getSubjectLifeCycle(), "D1-新增空间管理员角色人员（平台）-1-2-09新增身份人员-主体生命周期不能为空", false);
                            Assert.isNull(originalRoleMember_1.getSpaceId(), "D1-新增空间管理员角色人员（平台）-1-2-09新增身份人员-创建于空间ID不能为空", false);
                            Assert.isNull(originalRoleMember_1.getAppId(), "D1-新增空间管理员角色人员（平台）-1-2-09新增身份人员-创建于联盟应用ID不能为空", false);
                            string_16 = mOriginalRoleMemberService.addBeginMember(originalRoleMember_1)/*vcase invoke 本地 method 方法调用;*/;


                        }
                        String string_17 = null;
                        if (string_16 != null) {
                            OriginalRoleMemberInfo originalRoleMemberInfo_1 = new OriginalRoleMemberInfo();
                            if (string_16 != null) {
                                originalRoleMemberInfo_1.setOriginalRoleMemberId(string_16);//SimpleFieldAssign//sourceId:20473_1_728
                            }
                            if (reqDto != null) {
                                originalRoleMemberInfo_1.setRoleMemberCode(reqDto.getRoleMemberCode());//SimpleFieldAssign//sourceId:20474_1_728
                                originalRoleMemberInfo_1.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:20479_1_728
                                originalRoleMemberInfo_1.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:20480_1_728
                            }

                            /*1-2-10新增身份人员资料[113] 获取上一步出参的原始角色成员关系ID，创建原始角色成员关系资料（例如员工资料）；  */
                            Assert.isNull(originalRoleMemberInfo_1.getOriginalRoleMemberId(), "D1-新增空间管理员角色人员（平台）-1-2-10新增身份人员资料-身份人员ID不能为空", false);
                            Assert.isNull(originalRoleMemberInfo_1.getRoleMemberCode(), "D1-新增空间管理员角色人员（平台）-1-2-10新增身份人员资料-身份人员编号不能为空", false);
                            Assert.isNull(originalRoleMemberInfo_1.getSpaceId(), "D1-新增空间管理员角色人员（平台）-1-2-10新增身份人员资料-创建于空间ID不能为空", false);
                            Assert.isNull(originalRoleMemberInfo_1.getAppId(), "D1-新增空间管理员角色人员（平台）-1-2-10新增身份人员资料-创建于联盟应用ID不能为空", false);
                            string_17 = mOriginalRoleMemberInfoService.addBeginMembInfo(originalRoleMemberInfo_1)/*vcase invoke 本地 method 方法调用;*/;


                        }
                        SceneRole sceneRole_7 = null;
                        QueryRoleDetailReq queryRoleDetailReq_4 = new QueryRoleDetailReq();
                        queryRoleDetailReq_4.setRoleCode("ADMIN");//CUSTOM_CONVENTION//sourceId:29885_1_729
                        queryRoleDetailReq_4.setIsIdentity("FALSE");//sourceId:29886_1_729
                        queryRoleDetailReq_4.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:29887_1_729

                        /*1-2-08查询角色详情（查管理员普通角色ID）[170]   */
                        Assert.isNull(queryRoleDetailReq_4.getRoleCode(), "D1-新增空间管理员角色人员（平台）-1-2-08查询角色详情（查管理员普通角色ID）-角色标识不能为空", false);
                        Assert.isNull(queryRoleDetailReq_4.getIsIdentity(), "D1-新增空间管理员角色人员（平台）-1-2-08查询角色详情（查管理员普通角色ID）-是否身份角色不能为空", false);
                        Assert.isNull(queryRoleDetailReq_4.getSubjectLifeCycle(), "D1-新增空间管理员角色人员（平台）-1-2-08查询角色详情（查管理员普通角色ID）-主体生命周期不能为空", false);
                        sceneRole_7 = mSceneRoleService.queryRoleDetail(queryRoleDetailReq_4)/*vcase invoke 本地 method 方法调用;*/;


                        SceneRole sceneRole_8 = null;
                        QueryRoleDetailReq queryRoleDetailReq_5 = new QueryRoleDetailReq();
                        queryRoleDetailReq_5.setRoleCode("ORG_ADMIN");//CUSTOM_CONVENTION//sourceId:255943_1_14521
                        queryRoleDetailReq_5.setIsIdentity("FALSE");//sourceId:255944_1_14521
                        queryRoleDetailReq_5.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:255945_1_14521

                        /*1-2-08查询角色详情（查组织架构管理员业务角色ID）[170]   */
                        Assert.isNull(queryRoleDetailReq_5.getRoleCode(), "D1-新增空间管理员角色人员（平台）-1-2-08查询角色详情（查组织架构管理员业务角色ID）-角色标识不能为空", false);
                        Assert.isNull(queryRoleDetailReq_5.getIsIdentity(), "D1-新增空间管理员角色人员（平台）-1-2-08查询角色详情（查组织架构管理员业务角色ID）-是否身份角色不能为空", false);
                        Assert.isNull(queryRoleDetailReq_5.getSubjectLifeCycle(), "D1-新增空间管理员角色人员（平台）-1-2-08查询角色详情（查组织架构管理员业务角色ID）-主体生命周期不能为空", false);
                        sceneRole_8 = mSceneRoleService.queryRoleDetail(queryRoleDetailReq_5)/*vcase invoke 本地 method 方法调用;*/;
                        Assert.isTrue(sceneRole_8 == null || sceneRole_8.getRoleId() == null, "找不到数据，系统异常", false);


                        String string_18 = null;
                        if (string_16 != null && sceneRole_7 != null && users != null && userinfo_1 != null) {
                            RoleMember roleMember_2 = new RoleMember();
                            roleMember_2.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:20485_1_730
                            if (string_16 != null) {
                                roleMember_2.setOriginalRoleMemberId(string_16);//SimpleFieldAssign//sourceId:20481_1_730
                            }
                            if (sceneRole_7 != null) {
                                roleMember_2.setRoleId(sceneRole_7.getRoleId());//SimpleFieldAssign//sourceId:23813_1_730
                                roleMember_2.setRoleCode(sceneRole_7.getRoleCode());//SimpleFieldAssign//sourceId:20524_1_730
                            }
                            if (users != null) {
                                roleMember_2.setUserId(users.getUserId());//SimpleFieldAssign//sourceId:53750_1_730
                            }
                            if (userinfo_1 != null) {
                                roleMember_2.setFirstLetter(CommonFunctionHelper.firstChar(userinfo_1.getFirstLetter()));//FIRST_CHAR //todo 字段备注首位字母来源为空,请设置!!;//sourceId:20483_1_730
                            }
                            if (reqDto != null) {
                                roleMember_2.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:20486_1_730
                                roleMember_2.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:20487_1_730
                            }

                            /*1-2-13新增角色人员（空间管理员及组织架构管理员）[331] 根据前面出参原始角色成员关系ID，还有前端固化的角色编码ADMIN，生成非原始角色成员关系ID（管理员等）  */
                            Assert.isNull(roleMember_2.getOriginalRoleMemberId(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-身份人员ID不能为空", false);
                            Assert.isNull(roleMember_2.getRoleId(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-角色ID不能为空", false);
                            Assert.isNull(roleMember_2.getUserId(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-账号ID不能为空", false);
                            Assert.isNull(roleMember_2.getRoleCode(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-角色标识不能为空", false);
                            Assert.isNull(roleMember_2.getFirstLetter(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-备注首位字母不能为空", false);
                            Assert.isNull(roleMember_2.getSubjectLifeCycle(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-主体生命周期不能为空", false);
                            Assert.isNull(roleMember_2.getSpaceId(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-创建于空间ID不能为空", false);
                            Assert.isNull(roleMember_2.getAppId(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-创建于联盟应用ID不能为空", false);
                            string_18 = mRoleMemberService.addRoleRel(roleMember_2)/*vcase invoke 本地 method 方法调用;*/;


                            string_11 = string_18;
                        }
                        String string_19 = null;
                        if (string_16 != null && sceneRole_8 != null && users != null && userinfo_1 != null) {
                            RoleMember roleMember_3 = new RoleMember();
                            roleMember_3.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:20485_1_14522
                            if (string_16 != null) {
                                roleMember_3.setOriginalRoleMemberId(string_16);//SimpleFieldAssign//sourceId:20481_1_14522
                            }
                            if (sceneRole_8 != null) {
                                roleMember_3.setRoleId(sceneRole_8.getRoleId());//SimpleFieldAssign//sourceId:23813_1_14522
                                roleMember_3.setRoleCode(sceneRole_8.getRoleCode());//SimpleFieldAssign//sourceId:20524_1_14522
                            }
                            if (users != null) {
                                roleMember_3.setUserId(users.getUserId());//SimpleFieldAssign//sourceId:53750_1_14522
                            }
                            if (userinfo_1 != null) {
                                roleMember_3.setFirstLetter(CommonFunctionHelper.firstChar(userinfo_1.getFirstLetter()));//FIRST_CHAR //todo 字段备注首位字母来源为空,请设置!!;//sourceId:20483_1_14522
                            }
                            if (reqDto != null) {
                                roleMember_3.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:20486_1_14522
                                roleMember_3.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:20487_1_14522
                            }

                            /*1-2-13新增角色人员（空间管理员及组织架构管理员）[331] 根据前面出参原始角色成员关系ID，还有前端固化的角色编码ADMIN，生成非原始角色成员关系ID（管理员等）  */
                            Assert.isNull(roleMember_3.getOriginalRoleMemberId(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-身份人员ID不能为空", false);
                            Assert.isNull(roleMember_3.getRoleId(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-角色ID不能为空", false);
                            Assert.isNull(roleMember_3.getUserId(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-账号ID不能为空", false);
                            Assert.isNull(roleMember_3.getRoleCode(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-角色标识不能为空", false);
                            Assert.isNull(roleMember_3.getFirstLetter(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-备注首位字母不能为空", false);
                            Assert.isNull(roleMember_3.getSubjectLifeCycle(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-主体生命周期不能为空", false);
                            Assert.isNull(roleMember_3.getSpaceId(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-创建于空间ID不能为空", false);
                            Assert.isNull(roleMember_3.getAppId(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-创建于联盟应用ID不能为空", false);
                            string_19 = mRoleMemberService.addRoleRel(roleMember_3)/*vcase invoke 本地 method 方法调用;*/;


                            string_11 = string_19;
                        }
                        Organization organization_2 = null;
                        QueryOrgDetailReq queryOrgDetailReq_1 = new QueryOrgDetailReq();
                        queryOrgDetailReq_1.setIsHighOrg("TRUE");//sourceId:41177_1_731
                        if (reqDto != null) {
                            queryOrgDetailReq_1.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:41178_1_731
                        }

                        /*1-3-12查询组织详情[201]   */
                        Assert.isNull(queryOrgDetailReq_1.getIsHighOrg(), "D1-新增空间管理员角色人员（平台）-1-3-12查询组织详情-是否最高组织不能为空", false);
                        organization_2 = mOrganizationService.queryOrgDetail(queryOrgDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;


                        QueryItemMatchResultToAnswerDetailComRespDto queryItemMatchResultToAnswerDetailComRespDto_2 = null;
                        QueryItemMatchResultToAnswerDetailComReqDto queryItemMatchResultToAnswerDetailComReqDto_1 = new QueryItemMatchResultToAnswerDetailComReqDto();
                        queryItemMatchResultToAnswerDetailComReqDto_1.setConfItemCode("ORG_STRUCTURE_MODEL");//CUSTOM_CONVENTION//sourceId:105095_1_5661
                        queryItemMatchResultToAnswerDetailComReqDto_1.setResultAspObjType("TENANT_SPACE");//sourceId:105096_1_5661
                        queryItemMatchResultToAnswerDetailComReqDto_1.setResultAspObjId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:105097_1_5661
                        queryItemMatchResultToAnswerDetailComReqDto_1.setIsInitialScheme("TRUE");//sourceId:308465_1_5661
                        queryItemMatchResultToAnswerDetailComReqDto_1.setIsPlatData("FALSE");//sourceId:308466_1_5661

                        /*D2-3查询配置项匹配结果转答案(公共)[3094]   */
                        Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto_1.getConfItemCode(), "D1-新增空间管理员角色人员（平台）-D2-3查询配置项匹配结果转答案(公共)-配置项标识不能为空", false);
                        Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto_1.getResultAspObjType(), "D1-新增空间管理员角色人员（平台）-D2-3查询配置项匹配结果转答案(公共)-开通对象类型编码不能为空", false);
                        Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto_1.getResultAspObjId(), "D1-新增空间管理员角色人员（平台）-D2-3查询配置项匹配结果转答案(公共)-开通对象ID不能为空", false);
                        Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto_1.getIsInitialScheme(), "D1-新增空间管理员角色人员（平台）-D2-3查询配置项匹配结果转答案(公共)-是否初始方案答案不能为空", false);
                        Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto_1.getIsPlatData(), "D1-新增空间管理员角色人员（平台）-D2-3查询配置项匹配结果转答案(公共)-是否标准答案不能为空", false);
                        queryItemMatchResultToAnswerDetailComRespDto_2 = confSchemeService.queryItemMatchResultToAnswerDetailCom(queryItemMatchResultToAnswerDetailComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


//ModelCode: receptionService
                        QueryReceiveFieldDetailRespDto receptionServiceRes_2 = null;
                        if (string_16 != null && users != null) {
                            QueryReceiveFieldDetailReqDto receptionServiceReq_1 = new QueryReceiveFieldDetailReqDto();
                            if (string_16 != null) {
                                receptionServiceReq_1.setOriginalRoleMemberId(string_16);//SimpleFieldAssign//sourceId:1499886_1_60083
                            }
                            if (users != null) {
                                receptionServiceReq_1.setUserId(users.getUserId());//SimpleFieldAssign//sourceId:1499887_1_60083
                            }

                            /*约定出参：身份人员及账号[3715]  用于特殊方法接收上游入参。 */
                            Assert.isNull(receptionServiceReq_1.getOriginalRoleMemberId(), "D1-新增空间管理员角色人员（平台）-约定出参：身份人员及账号-身份人员ID不能为空", false);
                            Assert.isNull(receptionServiceReq_1.getUserId(), "D1-新增空间管理员角色人员（平台）-约定出参：身份人员及账号-账号不能为空", false);
                            receptionServiceRes_2 = nbMember.queryReceiveFieldDetail(receptionServiceReq_1);


                            receptionServiceRes_1 = receptionServiceRes_2;
                        }
                        if ((queryItemMatchResultToAnswerDetailComRespDto_2 != null && queryItemMatchResultToAnswerDetailComRespDto_2.getOrgStructureModel() != null)) {
                            //if(D2-3查询配置项匹配结果转答案(公共).空间组织架构模式 值不等于空 )  732

                            String string_20 = null;
                            if (organization_2 != null && string_16 != null && users != null) {
                                InductionRecord inductionRecord_1 = new InductionRecord();
                                inductionRecord_1.setInductionUnitTypeCode("ORG");//sourceId:41124_1_733
                                inductionRecord_1.setPositionType("MEMBER");//sourceId:63942_1_733
                                inductionRecord_1.setIsMainInduction("TRUE");//sourceId:41132_1_733
                                inductionRecord_1.setOrderNumber(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:285160_1_733
                                inductionRecord_1.setIsCustomPosition("TRUE");//sourceId:41133_1_733
                                inductionRecord_1.setPositionIdName("成员");//CUSTOM_CONVENTION//sourceId:41137_1_733
                                inductionRecord_1.setInductionStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:41157_1_733
                                inductionRecord_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:41200_1_733
                                inductionRecord_1.setIsUpdate("FALSE");//sourceId:281849_1_733
                                inductionRecord_1.setUpdateStatus("UNCHANGED");//sourceId:281850_1_733
                                inductionRecord_1.setIsEditing("FALSE");//sourceId:41201_1_733
                                inductionRecord_1.setIsDirector("FALSE");//sourceId:246856_1_733
                                if (organization_2 != null) {
                                    inductionRecord_1.setEntityId(organization_2.getOrganizationId());//SimpleFieldAssign//sourceId:41125_1_733
                                    inductionRecord_1.setOrganizationId(organization_2.getOrganizationId());//SimpleFieldAssign//sourceId:41128_1_733
                                    inductionRecord_1.setOrganizationName(organization_2.getOrganizationName());//SimpleFieldAssign//sourceId:161495_1_733
                                }
                                if (string_16 != null) {
                                    inductionRecord_1.setOriginalRoleMemberId(string_16);//SimpleFieldAssign//sourceId:41126_1_733
                                }
                                if (users != null) {
                                    inductionRecord_1.setUserId(users.getUserId());//SimpleFieldAssign//sourceId:41127_1_733
                                }
                                if (reqDto != null) {
                                    inductionRecord_1.setFirstLetter(CommonFunctionHelper.firstChar(reqDto.getIdCardName()));//FIRST_CHAR //todo 字段备注首位字母来源为空,请设置!!;//sourceId:41130_1_733
                                    inductionRecord_1.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:50362_1_733
                                    inductionRecord_1.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:50363_1_733
                                }

                                /*1-3-13新增就职记录[162]   */
                                Assert.isNull(inductionRecord_1.getInductionUnitTypeCode(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-就职单位类型实例不能为空", false);
                                Assert.isNull(inductionRecord_1.getEntityId(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-就职单位对象实例ID不能为空", false);
                                Assert.isNull(inductionRecord_1.getOriginalRoleMemberId(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-身份人员ID不能为空", false);
                                Assert.isNull(inductionRecord_1.getUserId(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-个人账号ID不能为空", false);
                                Assert.isNull(inductionRecord_1.getFirstLetter(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-备注首位字母不能为空", false);
                                Assert.isNull(inductionRecord_1.getOrganizationId(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-组织ID不能为空", false);
                                Assert.isNull(inductionRecord_1.getOrganizationName(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-冗余组织名称不能为空", false);
                                Assert.isNull(inductionRecord_1.getPositionType(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-职务性质不能为空", false);
                                Assert.isNull(inductionRecord_1.getIsMainInduction(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-是否主岗不能为空", false);
                                Assert.isNull(inductionRecord_1.getOrderNumber(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-排序不能为空", false);
                                Assert.isNull(inductionRecord_1.getIsCustomPosition(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-是否自定义职务不能为空", false);
                                Assert.isNull(inductionRecord_1.getPositionIdName(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-必选冗余职务名称不能为空", false);
                                Assert.isNull(inductionRecord_1.getSubjectLifeCycle(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-主体生命周期不能为空", false);
                                Assert.isNull(inductionRecord_1.getIsUpdate(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-批次下是否更新不能为空", false);
                                Assert.isNull(inductionRecord_1.getUpdateStatus(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-批次下更新状态不能为空", false);
                                Assert.isNull(inductionRecord_1.getIsEditing(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-是否未来不能为空", false);
                                Assert.isNull(inductionRecord_1.getIsDirector(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-是否主管不能为空", false);
                                Assert.isNull(inductionRecord_1.getSpaceId(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-创建于空间ID不能为空", false);
                                Assert.isNull(inductionRecord_1.getAppId(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-创建于联盟应用ID不能为空", false);
                                string_20 = mInductionRecordService.addInductionRecord(inductionRecord_1)/*vcase invoke 本地 method 方法调用;*/;


                            }
//processBranchName:正常结束 ,processBranchId:734

                        } else {
                            //else  735

//processBranchName:正常结束 ,processBranchId:737

                        }
                    } else {
                        //else  468

//异常结束 469
                        throw new BizException("10200005", "对不起，该成员已经存在，不可以新增！", false);
                    }
                }
            } else {
                //else  447

//异常结束 448
                throw new BizException("C00006", "对不起，验证码错误！", false);
            }
        } else {
            //else  443

            JudgeAddPerfectStaffUsableComRespDto judgeAddPerfectStaffUsableComRespDto_3 = null;
            JudgeAddPerfectStaffUsableComReqDto judgeAddPerfectStaffUsableComReqDto_2 = new JudgeAddPerfectStaffUsableComReqDto();
            judgeAddPerfectStaffUsableComReqDto_2.setRoleCode("TENANT_ORG_ADMIN");//CUSTOM_CONVENTION//sourceId:213949_1_13313
            judgeAddPerfectStaffUsableComReqDto_2.setPrivacyCode("TENANT_ORG_POWER_ADMIN");//CUSTOM_CONVENTION//sourceId:213950_1_13313
            if (reqDto != null) {
                judgeAddPerfectStaffUsableComReqDto_2.setUserName(reqDto.getUserName());//SimpleFieldAssign//sourceId:213944_1_13313
                judgeAddPerfectStaffUsableComReqDto_2.setRoleMemberCode(reqDto.getRoleMemberCode());//SimpleFieldAssign//sourceId:213945_1_13313
            }

            /*D1判断注册完善员工操作可用(公共)[4015]   */
            Assert.isNull(judgeAddPerfectStaffUsableComReqDto_2.getRoleMemberCode(), "D1-新增空间管理员角色人员（平台）-D1判断注册完善员工操作可用(公共)-身份人员编号不能为空", false);
            Assert.isNull(judgeAddPerfectStaffUsableComReqDto_2.getRoleCode(), "D1-新增空间管理员角色人员（平台）-D1判断注册完善员工操作可用(公共)-角色标识不能为空", false);
            Assert.isNull(judgeAddPerfectStaffUsableComReqDto_2.getPrivacyCode(), "D1-新增空间管理员角色人员（平台）-D1判断注册完善员工操作可用(公共)-权限标识不能为空", false);
            judgeAddPerfectStaffUsableComRespDto_3 = judgeAddPerfectStaffUsableCom(judgeAddPerfectStaffUsableComReqDto_2)/*vcase invoke 同服务,同domain*/;
            Assert.isTrue(judgeAddPerfectStaffUsableComRespDto_3 == null || judgeAddPerfectStaffUsableComRespDto_3.getOutputNum() == null, "找不到数据，系统异常", false);


            Users users_3 = null;
            QueryUserDetailReq queryUserDetailReq_1 = new QueryUserDetailReq();
            if (reqDto != null) {
                queryUserDetailReq_1.setPhone(reqDto.getPhone());//SimpleFieldAssign//sourceId:20424_1_444
            }

            /*1-2-01查询个人账号详情[286]  通过手机号进行账号查询，无就结束查询，执行下一步注册个人账号；如果有账号执行下一步查询；  */
            Assert.isNull(queryUserDetailReq_1.getPhone(), "D1-新增空间管理员角色人员（平台）-1-2-01查询个人账号详情-绑定手机不能为空", false);
            users_3 = mUsersService.queryUserDetail(queryUserDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;


            if ((users_3 == null)) {
                //if(1-2-01查询个人账号详情.出参 等于空 )  650

                String string_21 = null;
                Users users_4 = new Users();
                users_4.setPassByEmail("FALSE");//sourceId:20440_1_653
                users_4.setDevName(CommonFunctionHelper.getEquipMent());//GET_EQUIPMENT//sourceId:43818_1_653
                users_4.setInviteUserId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecUserId());//CURRENT_USERID//sourceId:20454_1_653
                if (reqDto != null) {
                    users_4.setUserName(reqDto.getUserName());//SimpleFieldAssign//sourceId:43816_1_653
                    users_4.setPassword(reqDto.getPassword());//SimpleFieldAssign//sourceId:43904_1_653
                    users_4.setIsPasswordExit(reqDto.getIsPasswordExit());//SimpleFieldAssign//sourceId:43817_1_653
                    users_4.setEmail(reqDto.getEmail());//SimpleFieldAssign//sourceId:43829_1_653
                    users_4.setPhone(reqDto.getPhone());//SimpleFieldAssign//sourceId:20441_1_653
                    users_4.setPassByPhone(reqDto.getPassByPhone());//SimpleFieldAssign//sourceId:20442_1_653
                    users_4.setIsUserInfoDone(reqDto.getIsUserInfoDone());//SimpleFieldAssign//sourceId:43811_1_653
                    users_4.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:20455_1_653
                    users_4.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:20456_1_653
                    users_4.setSenceId(reqDto.getSenceId());//SimpleFieldAssign//sourceId:43813_1_653
                }

                /*1-2-01新增个人账号[45] 前面判断没有个人账号，执行此步注册账号  */
                Assert.isNull(users_4.getPassword(), "D1-新增空间管理员角色人员（平台）-1-2-01新增个人账号-密码不能为空", false);
                Assert.isNull(users_4.getIsPasswordExit(), "D1-新增空间管理员角色人员（平台）-1-2-01新增个人账号-密码是否为空不能为空", false);
                Assert.isNull(users_4.getPassByEmail(), "D1-新增空间管理员角色人员（平台）-1-2-01新增个人账号-邮箱激活状态不能为空", false);
                Assert.isNull(users_4.getPhone(), "D1-新增空间管理员角色人员（平台）-1-2-01新增个人账号-绑定手机不能为空", false);
                Assert.isNull(users_4.getPassByPhone(), "D1-新增空间管理员角色人员（平台）-1-2-01新增个人账号-手机激活状态不能为空", false);
                Assert.isNull(users_4.getIsUserInfoDone(), "D1-新增空间管理员角色人员（平台）-1-2-01新增个人账号-个人资料是否完善不能为空", false);
                Assert.isNull(users_4.getInviteUserId(), "D1-新增空间管理员角色人员（平台）-1-2-01新增个人账号-邀请人账号不能为空", false);
                Assert.isNull(users_4.getSpaceId(), "D1-新增空间管理员角色人员（平台）-1-2-01新增个人账号-创建于空间ID不能为空", false);
                Assert.isNull(users_4.getAppId(), "D1-新增空间管理员角色人员（平台）-1-2-01新增个人账号-创建于联盟应用ID不能为空", false);
                Assert.isNull(users_4.getSenceId(), "D1-新增空间管理员角色人员（平台）-1-2-01新增个人账号-归属于场景ID不能为空", false);
                string_21 = mUsersService.addUser(users_4)/*vcase invoke 本地 method 方法调用;*/;


                String string_22 = null;
                if (string_21 != null) {
                    Userinfo userinfo_3 = new Userinfo();
                    if (string_21 != null) {
                        userinfo_3.setUserId(string_21);//SimpleFieldAssign//sourceId:20584_1_654
                    }
                    if (reqDto != null) {
                        userinfo_3.setIdCardName(reqDto.getIdCardName());//SimpleFieldAssign//sourceId:20585_1_654
                        userinfo_3.setFirstLetter(CommonFunctionHelper.firstChar(reqDto.getIdCardName()));//FIRST_CHAR //todo 字段备注首位字母来源为空,请设置!!;//sourceId:56813_1_654
                        userinfo_3.setUserFace(reqDto.getUserFace());//SimpleFieldAssign//sourceId:20587_1_654
                        userinfo_3.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:20592_1_654
                        userinfo_3.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:20593_1_654
                    }

                    /*1-2-02新增个人资料[49] 根据上一步入参的个人账号ID，生成个人资料。  */
                    Assert.isNull(userinfo_3.getUserId(), "D1-新增空间管理员角色人员（平台）-1-2-02新增个人资料-账号不能为空", false);
                    Assert.isNull(userinfo_3.getIdCardName(), "D1-新增空间管理员角色人员（平台）-1-2-02新增个人资料-真实姓名不能为空", false);
                    Assert.isNull(userinfo_3.getFirstLetter(), "D1-新增空间管理员角色人员（平台）-1-2-02新增个人资料-备注首位字母不能为空", false);
                    Assert.isNull(userinfo_3.getUserFace(), "D1-新增空间管理员角色人员（平台）-1-2-02新增个人资料-真实头像不能为空", false);
                    Assert.isNull(userinfo_3.getSpaceId(), "D1-新增空间管理员角色人员（平台）-1-2-02新增个人资料-创建于空间ID不能为空", false);
                    Assert.isNull(userinfo_3.getAppId(), "D1-新增空间管理员角色人员（平台）-1-2-02新增个人资料-归属应用ID不能为空", false);
                    string_22 = mUserinfoService.addUserinfo(userinfo_3)/*vcase invoke 本地 method 方法调用;*/;


                }
                String string_23 = null;
                if (string_21 != null) {
                    SpaceMember spaceMember_4 = new SpaceMember();
                    if (string_21 != null) {
                        spaceMember_4.setUserId(string_21);//SimpleFieldAssign//sourceId:20460_1_656
                    }
                    if (reqDto != null) {
                        spaceMember_4.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:20461_1_656
                        spaceMember_4.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:20462_1_656
                    }

                    /*1-2-05新增空间成员关系[61] 上一步注册个人账号成功出参后，本步生成成员ID  */
                    Assert.isNull(spaceMember_4.getUserId(), "D1-新增空间管理员角色人员（平台）-1-2-05新增空间成员关系-成员个人账号不能为空", false);
                    Assert.isNull(spaceMember_4.getSpaceId(), "D1-新增空间管理员角色人员（平台）-1-2-05新增空间成员关系-创建于空间ID不能为空", false);
                    Assert.isNull(spaceMember_4.getAppId(), "D1-新增空间管理员角色人员（平台）-1-2-05新增空间成员关系-创建于联盟应用ID不能为空", false);
                    string_23 = mSpaceMemberService.addMember(spaceMember_4)/*vcase invoke 本地 method 方法调用;*/;


                }
                SceneRole sceneRole_9 = null;
                QueryRoleDetailReq queryRoleDetailReq_6 = new QueryRoleDetailReq();
                queryRoleDetailReq_6.setRoleCode("STAFF");//CUSTOM_CONVENTION//sourceId:29850_1_657
                queryRoleDetailReq_6.setIsIdentity("TRUE");//sourceId:29851_1_657
                queryRoleDetailReq_6.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:29852_1_657
                queryRoleDetailReq_6.setIsArchive("FALSE");//sourceId:29853_1_657

                /*1-2-08查询角色详情（查员工身份角色ID）[170]   */
                Assert.isNull(queryRoleDetailReq_6.getRoleCode(), "D1-新增空间管理员角色人员（平台）-1-2-08查询角色详情（查员工身份角色ID）-角色标识不能为空", false);
                Assert.isNull(queryRoleDetailReq_6.getIsIdentity(), "D1-新增空间管理员角色人员（平台）-1-2-08查询角色详情（查员工身份角色ID）-是否身份角色不能为空", false);
                Assert.isNull(queryRoleDetailReq_6.getSubjectLifeCycle(), "D1-新增空间管理员角色人员（平台）-1-2-08查询角色详情（查员工身份角色ID）-主体生命周期不能为空", false);
                Assert.isNull(queryRoleDetailReq_6.getIsArchive(), "D1-新增空间管理员角色人员（平台）-1-2-08查询角色详情（查员工身份角色ID）-是否存档不能为空", false);
                sceneRole_9 = mSceneRoleService.queryRoleDetail(queryRoleDetailReq_6)/*vcase invoke 本地 method 方法调用;*/;


                String string_24 = null;
                if (string_23 != null && string_21 != null && sceneRole_9 != null) {
                    OriginalRoleMember originalRoleMember_2 = new OriginalRoleMember();
                    originalRoleMember_2.setSource("SET_WITHIN_ORG");//sourceId:20467_1_658
                    originalRoleMember_2.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:20469_1_658
                    if (string_23 != null) {
                        originalRoleMember_2.setMemberId(string_23);//SimpleFieldAssign//sourceId:20464_1_658
                    }
                    if (string_21 != null) {
                        originalRoleMember_2.setUserId(string_21);//SimpleFieldAssign//sourceId:23787_1_658
                    }
                    if (sceneRole_9 != null) {
                        originalRoleMember_2.setRoleId(sceneRole_9.getRoleId());//SimpleFieldAssign//sourceId:23814_1_658
                        originalRoleMember_2.setRoleCode(sceneRole_9.getRoleCode());//SimpleFieldAssign//sourceId:20522_1_658
                    }
                    if (reqDto != null) {
                        originalRoleMember_2.setFirstLetter(CommonFunctionHelper.firstChar(reqDto.getIdCardName()));//FIRST_CHAR //todo 字段备注首位字母来源为空,请设置!!;//sourceId:20466_1_658
                        originalRoleMember_2.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:20470_1_658
                        originalRoleMember_2.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:20471_1_658
                    }

                    /*1-2-09新增身份人员[77] 获取上一步出参的成员ID，还有前端固化的角色编码STAFF，生成员工原始角色身份的成员关系ID（例如员工等）。  */
                    Assert.isNull(originalRoleMember_2.getMemberId(), "D1-新增空间管理员角色人员（平台）-1-2-09新增身份人员-成员ID不能为空", false);
                    Assert.isNull(originalRoleMember_2.getUserId(), "D1-新增空间管理员角色人员（平台）-1-2-09新增身份人员-账号ID不能为空", false);
                    Assert.isNull(originalRoleMember_2.getRoleId(), "D1-新增空间管理员角色人员（平台）-1-2-09新增身份人员-身份角色ID不能为空", false);
                    Assert.isNull(originalRoleMember_2.getRoleCode(), "D1-新增空间管理员角色人员（平台）-1-2-09新增身份人员-身份角色编码不能为空", false);
                    Assert.isNull(originalRoleMember_2.getFirstLetter(), "D1-新增空间管理员角色人员（平台）-1-2-09新增身份人员-备注首位字母不能为空", false);
                    Assert.isNull(originalRoleMember_2.getSource(), "D1-新增空间管理员角色人员（平台）-1-2-09新增身份人员-关系建立来源不能为空", false);
                    Assert.isNull(originalRoleMember_2.getSubjectLifeCycle(), "D1-新增空间管理员角色人员（平台）-1-2-09新增身份人员-主体生命周期不能为空", false);
                    Assert.isNull(originalRoleMember_2.getSpaceId(), "D1-新增空间管理员角色人员（平台）-1-2-09新增身份人员-创建于空间ID不能为空", false);
                    Assert.isNull(originalRoleMember_2.getAppId(), "D1-新增空间管理员角色人员（平台）-1-2-09新增身份人员-创建于联盟应用ID不能为空", false);
                    string_24 = mOriginalRoleMemberService.addBeginMember(originalRoleMember_2)/*vcase invoke 本地 method 方法调用;*/;


                }
                String string_25 = null;
                if (string_24 != null) {
                    OriginalRoleMemberInfo originalRoleMemberInfo_2 = new OriginalRoleMemberInfo();
                    if (string_24 != null) {
                        originalRoleMemberInfo_2.setOriginalRoleMemberId(string_24);//SimpleFieldAssign//sourceId:20473_1_659
                    }
                    if (reqDto != null) {
                        originalRoleMemberInfo_2.setRoleMemberCode(reqDto.getRoleMemberCode());//SimpleFieldAssign//sourceId:20474_1_659
                        originalRoleMemberInfo_2.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:20479_1_659
                        originalRoleMemberInfo_2.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:20480_1_659
                    }

                    /*1-2-10新增身份人员资料[113] 获取上一步出参的原始角色成员关系ID，创建原始角色成员关系资料（例如员工资料）；  */
                    Assert.isNull(originalRoleMemberInfo_2.getOriginalRoleMemberId(), "D1-新增空间管理员角色人员（平台）-1-2-10新增身份人员资料-身份人员ID不能为空", false);
                    Assert.isNull(originalRoleMemberInfo_2.getRoleMemberCode(), "D1-新增空间管理员角色人员（平台）-1-2-10新增身份人员资料-身份人员编号不能为空", false);
                    Assert.isNull(originalRoleMemberInfo_2.getSpaceId(), "D1-新增空间管理员角色人员（平台）-1-2-10新增身份人员资料-创建于空间ID不能为空", false);
                    Assert.isNull(originalRoleMemberInfo_2.getAppId(), "D1-新增空间管理员角色人员（平台）-1-2-10新增身份人员资料-创建于联盟应用ID不能为空", false);
                    string_25 = mOriginalRoleMemberInfoService.addBeginMembInfo(originalRoleMemberInfo_2)/*vcase invoke 本地 method 方法调用;*/;


                }
                SceneRole sceneRole_10 = null;
                QueryRoleDetailReq queryRoleDetailReq_7 = new QueryRoleDetailReq();
                queryRoleDetailReq_7.setRoleCode("ADMIN");//CUSTOM_CONVENTION//sourceId:29885_1_660
                queryRoleDetailReq_7.setIsIdentity("FALSE");//sourceId:29886_1_660
                queryRoleDetailReq_7.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:29887_1_660

                /*1-2-08查询角色详情（查管理员普通角色ID）[170]   */
                Assert.isNull(queryRoleDetailReq_7.getRoleCode(), "D1-新增空间管理员角色人员（平台）-1-2-08查询角色详情（查管理员普通角色ID）-角色标识不能为空", false);
                Assert.isNull(queryRoleDetailReq_7.getIsIdentity(), "D1-新增空间管理员角色人员（平台）-1-2-08查询角色详情（查管理员普通角色ID）-是否身份角色不能为空", false);
                Assert.isNull(queryRoleDetailReq_7.getSubjectLifeCycle(), "D1-新增空间管理员角色人员（平台）-1-2-08查询角色详情（查管理员普通角色ID）-主体生命周期不能为空", false);
                sceneRole_10 = mSceneRoleService.queryRoleDetail(queryRoleDetailReq_7)/*vcase invoke 本地 method 方法调用;*/;


                SceneRole sceneRole_11 = null;
                QueryRoleDetailReq queryRoleDetailReq_8 = new QueryRoleDetailReq();
                queryRoleDetailReq_8.setRoleCode("ORG_ADMIN");//CUSTOM_CONVENTION//sourceId:255943_1_14523
                queryRoleDetailReq_8.setIsIdentity("FALSE");//sourceId:255944_1_14523
                queryRoleDetailReq_8.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:255945_1_14523

                /*1-2-08查询角色详情（查组织架构管理员业务角色ID）[170]   */
                Assert.isNull(queryRoleDetailReq_8.getRoleCode(), "D1-新增空间管理员角色人员（平台）-1-2-08查询角色详情（查组织架构管理员业务角色ID）-角色标识不能为空", false);
                Assert.isNull(queryRoleDetailReq_8.getIsIdentity(), "D1-新增空间管理员角色人员（平台）-1-2-08查询角色详情（查组织架构管理员业务角色ID）-是否身份角色不能为空", false);
                Assert.isNull(queryRoleDetailReq_8.getSubjectLifeCycle(), "D1-新增空间管理员角色人员（平台）-1-2-08查询角色详情（查组织架构管理员业务角色ID）-主体生命周期不能为空", false);
                sceneRole_11 = mSceneRoleService.queryRoleDetail(queryRoleDetailReq_8)/*vcase invoke 本地 method 方法调用;*/;
                Assert.isTrue(sceneRole_11 == null || sceneRole_11.getRoleId() == null, "找不到数据，系统异常", false);


                String string_26 = null;
                if (string_24 != null && sceneRole_10 != null && string_21 != null) {
                    RoleMember roleMember_4 = new RoleMember();
                    roleMember_4.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:20485_1_664
                    if (string_24 != null) {
                        roleMember_4.setOriginalRoleMemberId(string_24);//SimpleFieldAssign//sourceId:20481_1_664
                    }
                    if (sceneRole_10 != null) {
                        roleMember_4.setRoleId(sceneRole_10.getRoleId());//SimpleFieldAssign//sourceId:23813_1_664
                        roleMember_4.setRoleCode(sceneRole_10.getRoleCode());//SimpleFieldAssign//sourceId:20524_1_664
                    }
                    if (string_21 != null) {
                        roleMember_4.setUserId(string_21);//SimpleFieldAssign//sourceId:53750_1_664
                    }
                    if (reqDto != null) {
                        roleMember_4.setFirstLetter(CommonFunctionHelper.firstChar(reqDto.getIdCardName()));//FIRST_CHAR //todo 字段备注首位字母来源为空,请设置!!;//sourceId:20483_1_664
                        roleMember_4.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:20486_1_664
                        roleMember_4.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:20487_1_664
                    }

                    /*1-2-13新增角色人员（空间管理员及组织架构管理员）[331] 根据前面出参原始角色成员关系ID，还有前端固化的角色编码ADMIN，生成非原始角色成员关系ID（管理员等）  */
                    Assert.isNull(roleMember_4.getOriginalRoleMemberId(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-身份人员ID不能为空", false);
                    Assert.isNull(roleMember_4.getRoleId(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-角色ID不能为空", false);
                    Assert.isNull(roleMember_4.getUserId(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-账号ID不能为空", false);
                    Assert.isNull(roleMember_4.getRoleCode(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-角色标识不能为空", false);
                    Assert.isNull(roleMember_4.getFirstLetter(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-备注首位字母不能为空", false);
                    Assert.isNull(roleMember_4.getSubjectLifeCycle(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-主体生命周期不能为空", false);
                    Assert.isNull(roleMember_4.getSpaceId(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-创建于空间ID不能为空", false);
                    Assert.isNull(roleMember_4.getAppId(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-创建于联盟应用ID不能为空", false);
                    string_26 = mRoleMemberService.addRoleRel(roleMember_4)/*vcase invoke 本地 method 方法调用;*/;


                    string_11 = string_26;
                }
                String string_27 = null;
                if (string_24 != null && sceneRole_11 != null && string_21 != null) {
                    RoleMember roleMember_5 = new RoleMember();
                    roleMember_5.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:20485_1_14526
                    if (string_24 != null) {
                        roleMember_5.setOriginalRoleMemberId(string_24);//SimpleFieldAssign//sourceId:20481_1_14526
                    }
                    if (sceneRole_11 != null) {
                        roleMember_5.setRoleId(sceneRole_11.getRoleId());//SimpleFieldAssign//sourceId:23813_1_14526
                        roleMember_5.setRoleCode(sceneRole_11.getRoleCode());//SimpleFieldAssign//sourceId:20524_1_14526
                    }
                    if (string_21 != null) {
                        roleMember_5.setUserId(string_21);//SimpleFieldAssign//sourceId:53750_1_14526
                    }
                    if (reqDto != null) {
                        roleMember_5.setFirstLetter(CommonFunctionHelper.firstChar(reqDto.getIdCardName()));//FIRST_CHAR //todo 字段备注首位字母来源为空,请设置!!;//sourceId:20483_1_14526
                        roleMember_5.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:20486_1_14526
                        roleMember_5.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:20487_1_14526
                    }

                    /*1-2-13新增角色人员（空间管理员及组织架构管理员）[331] 根据前面出参原始角色成员关系ID，还有前端固化的角色编码ADMIN，生成非原始角色成员关系ID（管理员等）  */
                    Assert.isNull(roleMember_5.getOriginalRoleMemberId(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-身份人员ID不能为空", false);
                    Assert.isNull(roleMember_5.getRoleId(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-角色ID不能为空", false);
                    Assert.isNull(roleMember_5.getUserId(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-账号ID不能为空", false);
                    Assert.isNull(roleMember_5.getRoleCode(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-角色标识不能为空", false);
                    Assert.isNull(roleMember_5.getFirstLetter(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-备注首位字母不能为空", false);
                    Assert.isNull(roleMember_5.getSubjectLifeCycle(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-主体生命周期不能为空", false);
                    Assert.isNull(roleMember_5.getSpaceId(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-创建于空间ID不能为空", false);
                    Assert.isNull(roleMember_5.getAppId(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-创建于联盟应用ID不能为空", false);
                    string_27 = mRoleMemberService.addRoleRel(roleMember_5)/*vcase invoke 本地 method 方法调用;*/;


                    string_11 = string_27;
                }
                Organization organization_3 = null;
                QueryOrgDetailReq queryOrgDetailReq_2 = new QueryOrgDetailReq();
                queryOrgDetailReq_2.setIsHighOrg("TRUE");//sourceId:41177_1_666
                if (reqDto != null) {
                    queryOrgDetailReq_2.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:41178_1_666
                }

                /*1-3-12查询组织详情[201]   */
                Assert.isNull(queryOrgDetailReq_2.getIsHighOrg(), "D1-新增空间管理员角色人员（平台）-1-3-12查询组织详情-是否最高组织不能为空", false);
                organization_3 = mOrganizationService.queryOrgDetail(queryOrgDetailReq_2)/*vcase invoke 本地 method 方法调用;*/;


                QueryItemMatchResultToAnswerDetailComRespDto queryItemMatchResultToAnswerDetailComRespDto_3 = null;
                QueryItemMatchResultToAnswerDetailComReqDto queryItemMatchResultToAnswerDetailComReqDto_2 = new QueryItemMatchResultToAnswerDetailComReqDto();
                queryItemMatchResultToAnswerDetailComReqDto_2.setConfItemCode("ORG_STRUCTURE_MODEL");//CUSTOM_CONVENTION//sourceId:105095_1_5662
                queryItemMatchResultToAnswerDetailComReqDto_2.setResultAspObjType("TENANT_SPACE");//sourceId:105096_1_5662
                queryItemMatchResultToAnswerDetailComReqDto_2.setResultAspObjId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:105097_1_5662
                queryItemMatchResultToAnswerDetailComReqDto_2.setIsInitialScheme("TRUE");//sourceId:308465_1_5662
                queryItemMatchResultToAnswerDetailComReqDto_2.setIsPlatData("FALSE");//sourceId:308466_1_5662

                /*D2-3查询配置项匹配结果转答案(公共)[3094]   */
                Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto_2.getConfItemCode(), "D1-新增空间管理员角色人员（平台）-D2-3查询配置项匹配结果转答案(公共)-配置项标识不能为空", false);
                Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto_2.getResultAspObjType(), "D1-新增空间管理员角色人员（平台）-D2-3查询配置项匹配结果转答案(公共)-开通对象类型编码不能为空", false);
                Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto_2.getResultAspObjId(), "D1-新增空间管理员角色人员（平台）-D2-3查询配置项匹配结果转答案(公共)-开通对象ID不能为空", false);
                Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto_2.getIsInitialScheme(), "D1-新增空间管理员角色人员（平台）-D2-3查询配置项匹配结果转答案(公共)-是否初始方案答案不能为空", false);
                Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto_2.getIsPlatData(), "D1-新增空间管理员角色人员（平台）-D2-3查询配置项匹配结果转答案(公共)-是否标准答案不能为空", false);
                queryItemMatchResultToAnswerDetailComRespDto_3 = confSchemeService.queryItemMatchResultToAnswerDetailCom(queryItemMatchResultToAnswerDetailComReqDto_2).getData()/*vcase invoke 跨dubbo调用;*/;


//ModelCode: receptionService
                QueryReceiveFieldDetailRespDto receptionServiceRes_3 = null;
                if (string_24 != null && string_21 != null) {
                    QueryReceiveFieldDetailReqDto receptionServiceReq_2 = new QueryReceiveFieldDetailReqDto();
                    if (string_24 != null) {
                        receptionServiceReq_2.setOriginalRoleMemberId(string_24);//SimpleFieldAssign//sourceId:1499886_1_60084
                    }
                    if (string_21 != null) {
                        receptionServiceReq_2.setUserId(string_21);//SimpleFieldAssign//sourceId:1499887_1_60084
                    }

                    /*约定出参：身份人员及账号[3715]  用于特殊方法接收上游入参。 */
                    Assert.isNull(receptionServiceReq_2.getOriginalRoleMemberId(), "D1-新增空间管理员角色人员（平台）-约定出参：身份人员及账号-身份人员ID不能为空", false);
                    Assert.isNull(receptionServiceReq_2.getUserId(), "D1-新增空间管理员角色人员（平台）-约定出参：身份人员及账号-账号不能为空", false);
                    receptionServiceRes_3 = nbMember.queryReceiveFieldDetail(receptionServiceReq_2);


                    receptionServiceRes_1 = receptionServiceRes_3;
                }
                if ((queryItemMatchResultToAnswerDetailComRespDto_3 != null && queryItemMatchResultToAnswerDetailComRespDto_3.getOrgStructureModel() != null)) {
                    //if(D2-3查询配置项匹配结果转答案(公共).空间组织架构模式 值不等于空 )  667

                    String string_28 = null;
                    if (organization_3 != null && string_24 != null && string_21 != null) {
                        InductionRecord inductionRecord_2 = new InductionRecord();
                        inductionRecord_2.setInductionUnitTypeCode("ORG");//sourceId:41124_1_669
                        inductionRecord_2.setPositionType("MEMBER");//sourceId:63942_1_669
                        inductionRecord_2.setIsMainInduction("TRUE");//sourceId:41132_1_669
                        inductionRecord_2.setOrderNumber(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:285160_1_669
                        inductionRecord_2.setIsCustomPosition("TRUE");//sourceId:41133_1_669
                        inductionRecord_2.setPositionIdName("成员");//CUSTOM_CONVENTION//sourceId:41137_1_669
                        inductionRecord_2.setInductionStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:41157_1_669
                        inductionRecord_2.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:41200_1_669
                        inductionRecord_2.setIsUpdate("FALSE");//sourceId:281849_1_669
                        inductionRecord_2.setUpdateStatus("UNCHANGED");//sourceId:281850_1_669
                        inductionRecord_2.setIsEditing("FALSE");//sourceId:41201_1_669
                        inductionRecord_2.setIsDirector("FALSE");//sourceId:246856_1_669
                        if (organization_3 != null) {
                            inductionRecord_2.setEntityId(organization_3.getOrganizationId());//SimpleFieldAssign//sourceId:41125_1_669
                            inductionRecord_2.setOrganizationId(organization_3.getOrganizationId());//SimpleFieldAssign//sourceId:41128_1_669
                            inductionRecord_2.setOrganizationName(organization_3.getOrganizationName());//SimpleFieldAssign//sourceId:161495_1_669
                        }
                        if (string_24 != null) {
                            inductionRecord_2.setOriginalRoleMemberId(string_24);//SimpleFieldAssign//sourceId:41126_1_669
                        }
                        if (string_21 != null) {
                            inductionRecord_2.setUserId(string_21);//SimpleFieldAssign//sourceId:41127_1_669
                        }
                        if (reqDto != null) {
                            inductionRecord_2.setFirstLetter(CommonFunctionHelper.firstChar(reqDto.getIdCardName()));//FIRST_CHAR //todo 字段备注首位字母来源为空,请设置!!;//sourceId:41130_1_669
                            inductionRecord_2.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:50362_1_669
                            inductionRecord_2.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:50363_1_669
                        }

                        /*1-3-13新增就职记录[162]   */
                        Assert.isNull(inductionRecord_2.getInductionUnitTypeCode(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-就职单位类型实例不能为空", false);
                        Assert.isNull(inductionRecord_2.getEntityId(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-就职单位对象实例ID不能为空", false);
                        Assert.isNull(inductionRecord_2.getOriginalRoleMemberId(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-身份人员ID不能为空", false);
                        Assert.isNull(inductionRecord_2.getUserId(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-个人账号ID不能为空", false);
                        Assert.isNull(inductionRecord_2.getFirstLetter(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-备注首位字母不能为空", false);
                        Assert.isNull(inductionRecord_2.getOrganizationId(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-组织ID不能为空", false);
                        Assert.isNull(inductionRecord_2.getOrganizationName(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-冗余组织名称不能为空", false);
                        Assert.isNull(inductionRecord_2.getPositionType(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-职务性质不能为空", false);
                        Assert.isNull(inductionRecord_2.getIsMainInduction(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-是否主岗不能为空", false);
                        Assert.isNull(inductionRecord_2.getOrderNumber(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-排序不能为空", false);
                        Assert.isNull(inductionRecord_2.getIsCustomPosition(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-是否自定义职务不能为空", false);
                        Assert.isNull(inductionRecord_2.getPositionIdName(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-必选冗余职务名称不能为空", false);
                        Assert.isNull(inductionRecord_2.getSubjectLifeCycle(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-主体生命周期不能为空", false);
                        Assert.isNull(inductionRecord_2.getIsUpdate(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-批次下是否更新不能为空", false);
                        Assert.isNull(inductionRecord_2.getUpdateStatus(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-批次下更新状态不能为空", false);
                        Assert.isNull(inductionRecord_2.getIsEditing(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-是否未来不能为空", false);
                        Assert.isNull(inductionRecord_2.getIsDirector(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-是否主管不能为空", false);
                        Assert.isNull(inductionRecord_2.getSpaceId(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-创建于空间ID不能为空", false);
                        Assert.isNull(inductionRecord_2.getAppId(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-创建于联盟应用ID不能为空", false);
                        string_28 = mInductionRecordService.addInductionRecord(inductionRecord_2)/*vcase invoke 本地 method 方法调用;*/;


                    }
//processBranchName:正常结束 ,processBranchId:670

                } else {
                    //else  671

//processBranchName:正常结束 ,processBranchId:675

                }
            } else {
                //else  651

                JudgeAddPerfectStaffUsableComRespDto judgeAddPerfectStaffUsableComRespDto_4 = null;
                JudgeAddPerfectStaffUsableComReqDto judgeAddPerfectStaffUsableComReqDto_3 = new JudgeAddPerfectStaffUsableComReqDto();
                judgeAddPerfectStaffUsableComReqDto_3.setRoleCode("TENANT_ORG_ADMIN");//CUSTOM_CONVENTION//sourceId:213949_1_13314
                judgeAddPerfectStaffUsableComReqDto_3.setPrivacyCode("TENANT_ORG_POWER_ADMIN");//CUSTOM_CONVENTION//sourceId:213950_1_13314
                if (reqDto != null) {
                    judgeAddPerfectStaffUsableComReqDto_3.setUserName(reqDto.getUserName());//SimpleFieldAssign//sourceId:213944_1_13314
                    judgeAddPerfectStaffUsableComReqDto_3.setRoleMemberCode(reqDto.getRoleMemberCode());//SimpleFieldAssign//sourceId:213945_1_13314
                }

                /*D1判断注册完善员工操作可用(公共)[4015]   */
                Assert.isNull(judgeAddPerfectStaffUsableComReqDto_3.getRoleMemberCode(), "D1-新增空间管理员角色人员（平台）-D1判断注册完善员工操作可用(公共)-身份人员编号不能为空", false);
                Assert.isNull(judgeAddPerfectStaffUsableComReqDto_3.getRoleCode(), "D1-新增空间管理员角色人员（平台）-D1判断注册完善员工操作可用(公共)-角色标识不能为空", false);
                Assert.isNull(judgeAddPerfectStaffUsableComReqDto_3.getPrivacyCode(), "D1-新增空间管理员角色人员（平台）-D1判断注册完善员工操作可用(公共)-权限标识不能为空", false);
                judgeAddPerfectStaffUsableComRespDto_4 = judgeAddPerfectStaffUsableCom(judgeAddPerfectStaffUsableComReqDto_3)/*vcase invoke 同服务,同domain*/;
                Assert.isTrue(judgeAddPerfectStaffUsableComRespDto_4 == null || judgeAddPerfectStaffUsableComRespDto_4.getOutputNum() == null, "找不到数据，系统异常", false);


                SpaceMember spaceMember_5 = null;
                if (users_3 != null) {
                    QueryMemberDetailReq queryMemberDetailReq_1 = new QueryMemberDetailReq();
                    if (users_3 != null) {
                        queryMemberDetailReq_1.setUserId(users_3.getUserId());//SimpleFieldAssign//sourceId:20430_1_652
                    }
                    if (reqDto != null) {
                        queryMemberDetailReq_1.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:20520_1_652
                    }

                    /*1-2-05查询空间成员关系详情[167] 通过上一步出参的个人账号查询成员ID，无就结束查询，执行下一步生成成员ID，；如果有成员ID就出参（表示已经是成员，前端报错告知有此人，不可设成员）  */
                    Assert.isNull(queryMemberDetailReq_1.getUserId(), "D1-新增空间管理员角色人员（平台）-1-2-05查询空间成员关系详情-成员个人账号不能为空", false);
                    Assert.isNull(queryMemberDetailReq_1.getSpaceId(), "D1-新增空间管理员角色人员（平台）-1-2-05查询空间成员关系详情-创建于空间ID不能为空", false);
                    spaceMember_5 = mSpaceMemberService.queryMemberDetail(queryMemberDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;


                }
                if ((spaceMember_5 == null)) {
                    //if(1-2-05查询空间成员关系详情.出参 等于空 )  681

                    String string_29 = null;
                    if (users_3 != null) {
                        SpaceMember spaceMember_6 = new SpaceMember();
                        if (users_3 != null) {
                            spaceMember_6.setUserId(users_3.getUserId());//SimpleFieldAssign//sourceId:20460_1_685
                        }
                        if (reqDto != null) {
                            spaceMember_6.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:20461_1_685
                            spaceMember_6.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:20462_1_685
                        }

                        /*1-2-05新增空间成员关系[61] 上一步注册个人账号成功出参后，本步生成成员ID  */
                        Assert.isNull(spaceMember_6.getUserId(), "D1-新增空间管理员角色人员（平台）-1-2-05新增空间成员关系-成员个人账号不能为空", false);
                        Assert.isNull(spaceMember_6.getSpaceId(), "D1-新增空间管理员角色人员（平台）-1-2-05新增空间成员关系-创建于空间ID不能为空", false);
                        Assert.isNull(spaceMember_6.getAppId(), "D1-新增空间管理员角色人员（平台）-1-2-05新增空间成员关系-创建于联盟应用ID不能为空", false);
                        string_29 = mSpaceMemberService.addMember(spaceMember_6)/*vcase invoke 本地 method 方法调用;*/;


                    }
                    SceneRole sceneRole_12 = null;
                    QueryRoleDetailReq queryRoleDetailReq_9 = new QueryRoleDetailReq();
                    queryRoleDetailReq_9.setRoleCode("STAFF");//CUSTOM_CONVENTION//sourceId:29850_1_686
                    queryRoleDetailReq_9.setIsIdentity("TRUE");//sourceId:29851_1_686
                    queryRoleDetailReq_9.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:29852_1_686
                    queryRoleDetailReq_9.setIsArchive("FALSE");//sourceId:29853_1_686

                    /*1-2-08查询角色详情（查员工身份角色ID）[170]   */
                    Assert.isNull(queryRoleDetailReq_9.getRoleCode(), "D1-新增空间管理员角色人员（平台）-1-2-08查询角色详情（查员工身份角色ID）-角色标识不能为空", false);
                    Assert.isNull(queryRoleDetailReq_9.getIsIdentity(), "D1-新增空间管理员角色人员（平台）-1-2-08查询角色详情（查员工身份角色ID）-是否身份角色不能为空", false);
                    Assert.isNull(queryRoleDetailReq_9.getSubjectLifeCycle(), "D1-新增空间管理员角色人员（平台）-1-2-08查询角色详情（查员工身份角色ID）-主体生命周期不能为空", false);
                    Assert.isNull(queryRoleDetailReq_9.getIsArchive(), "D1-新增空间管理员角色人员（平台）-1-2-08查询角色详情（查员工身份角色ID）-是否存档不能为空", false);
                    sceneRole_12 = mSceneRoleService.queryRoleDetail(queryRoleDetailReq_9)/*vcase invoke 本地 method 方法调用;*/;


                    Userinfo userinfo_4 = null;
                    if (users_3 != null) {
                        QueryUserinfoDetailReq queryUserinfoDetailReq_1 = new QueryUserinfoDetailReq();
                        if (users_3 != null) {
                            queryUserinfoDetailReq_1.setUserId(users_3.getUserId());//SimpleFieldAssign//sourceId:41863_1_738
                        }

                        /*1-2-02查询个人资料详情（查首字母）[155]   */
                        Assert.isNull(queryUserinfoDetailReq_1.getUserId(), "D1-新增空间管理员角色人员（平台）-1-2-02查询个人资料详情（查首字母）-账号不能为空", false);
                        userinfo_4 = mUserinfoService.queryUserinfoDetail(queryUserinfoDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;


                    }
                    String string_30 = null;
                    if (string_29 != null && users_3 != null && sceneRole_12 != null && userinfo_4 != null) {
                        OriginalRoleMember originalRoleMember_3 = new OriginalRoleMember();
                        originalRoleMember_3.setSource("SET_WITHIN_ORG");//sourceId:20467_1_739
                        originalRoleMember_3.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:20469_1_739
                        if (string_29 != null) {
                            originalRoleMember_3.setMemberId(string_29);//SimpleFieldAssign//sourceId:20464_1_739
                        }
                        if (users_3 != null) {
                            originalRoleMember_3.setUserId(users_3.getUserId());//SimpleFieldAssign//sourceId:23787_1_739
                        }
                        if (sceneRole_12 != null) {
                            originalRoleMember_3.setRoleId(sceneRole_12.getRoleId());//SimpleFieldAssign//sourceId:23814_1_739
                            originalRoleMember_3.setRoleCode(sceneRole_12.getRoleCode());//SimpleFieldAssign//sourceId:20522_1_739
                        }
                        if (userinfo_4 != null) {
                            originalRoleMember_3.setFirstLetter(CommonFunctionHelper.firstChar(userinfo_4.getFirstLetter()));//FIRST_CHAR //todo 字段备注首位字母来源为空,请设置!!;//sourceId:20466_1_739
                        }
                        if (reqDto != null) {
                            originalRoleMember_3.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:20470_1_739
                            originalRoleMember_3.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:20471_1_739
                        }

                        /*1-2-09新增身份人员[77] 获取上一步出参的成员ID，还有前端固化的角色编码STAFF，生成员工原始角色身份的成员关系ID（例如员工等）。  */
                        Assert.isNull(originalRoleMember_3.getMemberId(), "D1-新增空间管理员角色人员（平台）-1-2-09新增身份人员-成员ID不能为空", false);
                        Assert.isNull(originalRoleMember_3.getUserId(), "D1-新增空间管理员角色人员（平台）-1-2-09新增身份人员-账号ID不能为空", false);
                        Assert.isNull(originalRoleMember_3.getRoleId(), "D1-新增空间管理员角色人员（平台）-1-2-09新增身份人员-身份角色ID不能为空", false);
                        Assert.isNull(originalRoleMember_3.getRoleCode(), "D1-新增空间管理员角色人员（平台）-1-2-09新增身份人员-身份角色编码不能为空", false);
                        Assert.isNull(originalRoleMember_3.getFirstLetter(), "D1-新增空间管理员角色人员（平台）-1-2-09新增身份人员-备注首位字母不能为空", false);
                        Assert.isNull(originalRoleMember_3.getSource(), "D1-新增空间管理员角色人员（平台）-1-2-09新增身份人员-关系建立来源不能为空", false);
                        Assert.isNull(originalRoleMember_3.getSubjectLifeCycle(), "D1-新增空间管理员角色人员（平台）-1-2-09新增身份人员-主体生命周期不能为空", false);
                        Assert.isNull(originalRoleMember_3.getSpaceId(), "D1-新增空间管理员角色人员（平台）-1-2-09新增身份人员-创建于空间ID不能为空", false);
                        Assert.isNull(originalRoleMember_3.getAppId(), "D1-新增空间管理员角色人员（平台）-1-2-09新增身份人员-创建于联盟应用ID不能为空", false);
                        string_30 = mOriginalRoleMemberService.addBeginMember(originalRoleMember_3)/*vcase invoke 本地 method 方法调用;*/;


                    }
                    String string_31 = null;
                    if (string_30 != null) {
                        OriginalRoleMemberInfo originalRoleMemberInfo_3 = new OriginalRoleMemberInfo();
                        if (string_30 != null) {
                            originalRoleMemberInfo_3.setOriginalRoleMemberId(string_30);//SimpleFieldAssign//sourceId:20473_1_740
                        }
                        if (reqDto != null) {
                            originalRoleMemberInfo_3.setRoleMemberCode(reqDto.getRoleMemberCode());//SimpleFieldAssign//sourceId:20474_1_740
                            originalRoleMemberInfo_3.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:20479_1_740
                            originalRoleMemberInfo_3.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:20480_1_740
                        }

                        /*1-2-10新增身份人员资料[113] 获取上一步出参的原始角色成员关系ID，创建原始角色成员关系资料（例如员工资料）；  */
                        Assert.isNull(originalRoleMemberInfo_3.getOriginalRoleMemberId(), "D1-新增空间管理员角色人员（平台）-1-2-10新增身份人员资料-身份人员ID不能为空", false);
                        Assert.isNull(originalRoleMemberInfo_3.getRoleMemberCode(), "D1-新增空间管理员角色人员（平台）-1-2-10新增身份人员资料-身份人员编号不能为空", false);
                        Assert.isNull(originalRoleMemberInfo_3.getSpaceId(), "D1-新增空间管理员角色人员（平台）-1-2-10新增身份人员资料-创建于空间ID不能为空", false);
                        Assert.isNull(originalRoleMemberInfo_3.getAppId(), "D1-新增空间管理员角色人员（平台）-1-2-10新增身份人员资料-创建于联盟应用ID不能为空", false);
                        string_31 = mOriginalRoleMemberInfoService.addBeginMembInfo(originalRoleMemberInfo_3)/*vcase invoke 本地 method 方法调用;*/;


                    }
                    SceneRole sceneRole_13 = null;
                    QueryRoleDetailReq queryRoleDetailReq_10 = new QueryRoleDetailReq();
                    queryRoleDetailReq_10.setRoleCode("ADMIN");//CUSTOM_CONVENTION//sourceId:29885_1_741
                    queryRoleDetailReq_10.setIsIdentity("FALSE");//sourceId:29886_1_741
                    queryRoleDetailReq_10.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:29887_1_741

                    /*1-2-08查询角色详情（查管理员普通角色ID）[170]   */
                    Assert.isNull(queryRoleDetailReq_10.getRoleCode(), "D1-新增空间管理员角色人员（平台）-1-2-08查询角色详情（查管理员普通角色ID）-角色标识不能为空", false);
                    Assert.isNull(queryRoleDetailReq_10.getIsIdentity(), "D1-新增空间管理员角色人员（平台）-1-2-08查询角色详情（查管理员普通角色ID）-是否身份角色不能为空", false);
                    Assert.isNull(queryRoleDetailReq_10.getSubjectLifeCycle(), "D1-新增空间管理员角色人员（平台）-1-2-08查询角色详情（查管理员普通角色ID）-主体生命周期不能为空", false);
                    sceneRole_13 = mSceneRoleService.queryRoleDetail(queryRoleDetailReq_10)/*vcase invoke 本地 method 方法调用;*/;


                    SceneRole sceneRole_14 = null;
                    QueryRoleDetailReq queryRoleDetailReq_11 = new QueryRoleDetailReq();
                    queryRoleDetailReq_11.setRoleCode("ORG_ADMIN");//CUSTOM_CONVENTION//sourceId:255943_1_14524
                    queryRoleDetailReq_11.setIsIdentity("FALSE");//sourceId:255944_1_14524
                    queryRoleDetailReq_11.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:255945_1_14524

                    /*1-2-08查询角色详情（查组织架构管理员业务角色ID）[170]   */
                    Assert.isNull(queryRoleDetailReq_11.getRoleCode(), "D1-新增空间管理员角色人员（平台）-1-2-08查询角色详情（查组织架构管理员业务角色ID）-角色标识不能为空", false);
                    Assert.isNull(queryRoleDetailReq_11.getIsIdentity(), "D1-新增空间管理员角色人员（平台）-1-2-08查询角色详情（查组织架构管理员业务角色ID）-是否身份角色不能为空", false);
                    Assert.isNull(queryRoleDetailReq_11.getSubjectLifeCycle(), "D1-新增空间管理员角色人员（平台）-1-2-08查询角色详情（查组织架构管理员业务角色ID）-主体生命周期不能为空", false);
                    sceneRole_14 = mSceneRoleService.queryRoleDetail(queryRoleDetailReq_11)/*vcase invoke 本地 method 方法调用;*/;
                    Assert.isTrue(sceneRole_14 == null || sceneRole_14.getRoleId() == null, "找不到数据，系统异常", false);


                    String string_32 = null;
                    if (string_30 != null && sceneRole_12 != null && users_3 != null && sceneRole_13 != null && userinfo_4 != null) {
                        RoleMember roleMember_6 = new RoleMember();
                        roleMember_6.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:20485_1_742
                        if (string_30 != null) {
                            roleMember_6.setOriginalRoleMemberId(string_30);//SimpleFieldAssign//sourceId:20481_1_742
                        }
                        if (sceneRole_12 != null) {
                            roleMember_6.setRoleId(sceneRole_12.getRoleId());//SimpleFieldAssign//sourceId:23813_1_742
                        }
                        if (users_3 != null) {
                            roleMember_6.setUserId(users_3.getUserId());//SimpleFieldAssign//sourceId:53750_1_742
                        }
                        if (sceneRole_13 != null) {
                            roleMember_6.setRoleCode(sceneRole_13.getRoleCode());//SimpleFieldAssign//sourceId:20524_1_742
                        }
                        if (userinfo_4 != null) {
                            roleMember_6.setFirstLetter(CommonFunctionHelper.firstChar(userinfo_4.getFirstLetter()));//FIRST_CHAR //todo 字段备注首位字母来源为空,请设置!!;//sourceId:20483_1_742
                        }
                        if (reqDto != null) {
                            roleMember_6.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:20486_1_742
                            roleMember_6.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:20487_1_742
                        }

                        /*1-2-13新增角色人员（空间管理员及组织架构管理员）[331] 根据前面出参原始角色成员关系ID，还有前端固化的角色编码ADMIN，生成非原始角色成员关系ID（管理员等）  */
                        Assert.isNull(roleMember_6.getOriginalRoleMemberId(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-身份人员ID不能为空", false);
                        Assert.isNull(roleMember_6.getRoleId(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-角色ID不能为空", false);
                        Assert.isNull(roleMember_6.getUserId(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-账号ID不能为空", false);
                        Assert.isNull(roleMember_6.getRoleCode(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-角色标识不能为空", false);
                        Assert.isNull(roleMember_6.getFirstLetter(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-备注首位字母不能为空", false);
                        Assert.isNull(roleMember_6.getSubjectLifeCycle(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-主体生命周期不能为空", false);
                        Assert.isNull(roleMember_6.getSpaceId(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-创建于空间ID不能为空", false);
                        Assert.isNull(roleMember_6.getAppId(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-创建于联盟应用ID不能为空", false);
                        string_32 = mRoleMemberService.addRoleRel(roleMember_6)/*vcase invoke 本地 method 方法调用;*/;


                        string_11 = string_32;
                    }
                    String string_33 = null;
                    if (string_30 != null && users_3 != null && sceneRole_14 != null && userinfo_4 != null) {
                        RoleMember roleMember_7 = new RoleMember();
                        roleMember_7.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:20485_1_14525
                        if (string_30 != null) {
                            roleMember_7.setOriginalRoleMemberId(string_30);//SimpleFieldAssign//sourceId:20481_1_14525
                        }
                        if (users_3 != null) {
                            roleMember_7.setUserId(users_3.getUserId());//SimpleFieldAssign//sourceId:53750_1_14525
                        }
                        if (sceneRole_14 != null) {
                            roleMember_7.setRoleId(sceneRole_14.getRoleId());//SimpleFieldAssign//sourceId:23813_1_14525
                            roleMember_7.setRoleCode(sceneRole_14.getRoleCode());//SimpleFieldAssign//sourceId:20524_1_14525
                        }
                        if (userinfo_4 != null) {
                            roleMember_7.setFirstLetter(CommonFunctionHelper.firstChar(userinfo_4.getFirstLetter()));//FIRST_CHAR //todo 字段备注首位字母来源为空,请设置!!;//sourceId:20483_1_14525
                        }
                        if (reqDto != null) {
                            roleMember_7.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:20486_1_14525
                            roleMember_7.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:20487_1_14525
                        }

                        /*1-2-13新增角色人员（空间管理员及组织架构管理员）[331] 根据前面出参原始角色成员关系ID，还有前端固化的角色编码ADMIN，生成非原始角色成员关系ID（管理员等）  */
                        Assert.isNull(roleMember_7.getOriginalRoleMemberId(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-身份人员ID不能为空", false);
                        Assert.isNull(roleMember_7.getUserId(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-账号ID不能为空", false);
                        Assert.isNull(roleMember_7.getRoleId(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-角色ID不能为空", false);
                        Assert.isNull(roleMember_7.getRoleCode(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-角色标识不能为空", false);
                        Assert.isNull(roleMember_7.getFirstLetter(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-备注首位字母不能为空", false);
                        Assert.isNull(roleMember_7.getSubjectLifeCycle(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-主体生命周期不能为空", false);
                        Assert.isNull(roleMember_7.getSpaceId(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-创建于空间ID不能为空", false);
                        Assert.isNull(roleMember_7.getAppId(), "D1-新增空间管理员角色人员（平台）-1-2-13新增角色人员（空间管理员及组织架构管理员）-创建于联盟应用ID不能为空", false);
                        string_33 = mRoleMemberService.addRoleRel(roleMember_7)/*vcase invoke 本地 method 方法调用;*/;


                        string_11 = string_33;
                    }
                    Organization organization_4 = null;
                    QueryOrgDetailReq queryOrgDetailReq_3 = new QueryOrgDetailReq();
                    queryOrgDetailReq_3.setIsHighOrg("TRUE");//sourceId:41177_1_743
                    if (reqDto != null) {
                        queryOrgDetailReq_3.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:41178_1_743
                    }

                    /*1-3-12查询组织详情[201]   */
                    Assert.isNull(queryOrgDetailReq_3.getIsHighOrg(), "D1-新增空间管理员角色人员（平台）-1-3-12查询组织详情-是否最高组织不能为空", false);
                    organization_4 = mOrganizationService.queryOrgDetail(queryOrgDetailReq_3)/*vcase invoke 本地 method 方法调用;*/;


                    QueryItemMatchResultToAnswerDetailComRespDto queryItemMatchResultToAnswerDetailComRespDto_4 = null;
                    QueryItemMatchResultToAnswerDetailComReqDto queryItemMatchResultToAnswerDetailComReqDto_3 = new QueryItemMatchResultToAnswerDetailComReqDto();
                    queryItemMatchResultToAnswerDetailComReqDto_3.setConfItemCode("ORG_STRUCTURE_MODEL");//CUSTOM_CONVENTION//sourceId:105095_1_5663
                    queryItemMatchResultToAnswerDetailComReqDto_3.setResultAspObjType("TENANT_SPACE");//sourceId:105096_1_5663
                    queryItemMatchResultToAnswerDetailComReqDto_3.setResultAspObjId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:105097_1_5663
                    queryItemMatchResultToAnswerDetailComReqDto_3.setIsInitialScheme("TRUE");//sourceId:308465_1_5663
                    queryItemMatchResultToAnswerDetailComReqDto_3.setIsPlatData("FALSE");//sourceId:308466_1_5663

                    /*D2-3查询配置项匹配结果转答案(公共)[3094]   */
                    Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto_3.getConfItemCode(), "D1-新增空间管理员角色人员（平台）-D2-3查询配置项匹配结果转答案(公共)-配置项标识不能为空", false);
                    Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto_3.getResultAspObjType(), "D1-新增空间管理员角色人员（平台）-D2-3查询配置项匹配结果转答案(公共)-开通对象类型编码不能为空", false);
                    Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto_3.getResultAspObjId(), "D1-新增空间管理员角色人员（平台）-D2-3查询配置项匹配结果转答案(公共)-开通对象ID不能为空", false);
                    Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto_3.getIsInitialScheme(), "D1-新增空间管理员角色人员（平台）-D2-3查询配置项匹配结果转答案(公共)-是否初始方案答案不能为空", false);
                    Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto_3.getIsPlatData(), "D1-新增空间管理员角色人员（平台）-D2-3查询配置项匹配结果转答案(公共)-是否标准答案不能为空", false);
                    queryItemMatchResultToAnswerDetailComRespDto_4 = confSchemeService.queryItemMatchResultToAnswerDetailCom(queryItemMatchResultToAnswerDetailComReqDto_3).getData()/*vcase invoke 跨dubbo调用;*/;


//ModelCode: receptionService
                    QueryReceiveFieldDetailRespDto receptionServiceRes_4 = null;
                    if (string_30 != null && users_3 != null) {
                        QueryReceiveFieldDetailReqDto receptionServiceReq_3 = new QueryReceiveFieldDetailReqDto();
                        if (string_30 != null) {
                            receptionServiceReq_3.setOriginalRoleMemberId(string_30);//SimpleFieldAssign//sourceId:1499886_1_60085
                        }
                        if (users_3 != null) {
                            receptionServiceReq_3.setUserId(users_3.getUserId());//SimpleFieldAssign//sourceId:1499887_1_60085
                        }

                        /*约定出参：身份人员及账号[3715]  用于特殊方法接收上游入参。 */
                        Assert.isNull(receptionServiceReq_3.getOriginalRoleMemberId(), "D1-新增空间管理员角色人员（平台）-约定出参：身份人员及账号-身份人员ID不能为空", false);
                        Assert.isNull(receptionServiceReq_3.getUserId(), "D1-新增空间管理员角色人员（平台）-约定出参：身份人员及账号-账号不能为空", false);
                        receptionServiceRes_4 = nbMember.queryReceiveFieldDetail(receptionServiceReq_3);


                        receptionServiceRes_1 = receptionServiceRes_4;
                    }
                    if ((queryItemMatchResultToAnswerDetailComRespDto_4 != null && queryItemMatchResultToAnswerDetailComRespDto_4.getOrgStructureModel() != null)) {
                        //if(D2-3查询配置项匹配结果转答案(公共).空间组织架构模式 值不等于空 )  744

                        String string_34 = null;
                        if (organization_4 != null && string_30 != null && users_3 != null) {
                            InductionRecord inductionRecord_3 = new InductionRecord();
                            inductionRecord_3.setInductionUnitTypeCode("ORG");//sourceId:41124_1_745
                            inductionRecord_3.setPositionType("MEMBER");//sourceId:63942_1_745
                            inductionRecord_3.setIsMainInduction("TRUE");//sourceId:41132_1_745
                            inductionRecord_3.setOrderNumber(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:285160_1_745
                            inductionRecord_3.setIsCustomPosition("TRUE");//sourceId:41133_1_745
                            inductionRecord_3.setPositionIdName("成员");//CUSTOM_CONVENTION//sourceId:41137_1_745
                            inductionRecord_3.setInductionStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:41157_1_745
                            inductionRecord_3.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:41200_1_745
                            inductionRecord_3.setIsUpdate("FALSE");//sourceId:281849_1_745
                            inductionRecord_3.setUpdateStatus("UNCHANGED");//sourceId:281850_1_745
                            inductionRecord_3.setIsEditing("FALSE");//sourceId:41201_1_745
                            inductionRecord_3.setIsDirector("FALSE");//sourceId:246856_1_745
                            if (organization_4 != null) {
                                inductionRecord_3.setEntityId(organization_4.getOrganizationId());//SimpleFieldAssign//sourceId:41125_1_745
                                inductionRecord_3.setOrganizationId(organization_4.getOrganizationId());//SimpleFieldAssign//sourceId:41128_1_745
                                inductionRecord_3.setOrganizationName(organization_4.getOrganizationName());//SimpleFieldAssign//sourceId:161495_1_745
                            }
                            if (string_30 != null) {
                                inductionRecord_3.setOriginalRoleMemberId(string_30);//SimpleFieldAssign//sourceId:41126_1_745
                            }
                            if (users_3 != null) {
                                inductionRecord_3.setUserId(users_3.getUserId());//SimpleFieldAssign//sourceId:41127_1_745
                            }
                            if (reqDto != null) {
                                inductionRecord_3.setFirstLetter(CommonFunctionHelper.firstChar(reqDto.getIdCardName()));//FIRST_CHAR //todo 字段备注首位字母来源为空,请设置!!;//sourceId:41130_1_745
                                inductionRecord_3.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:50362_1_745
                                inductionRecord_3.setAppId(reqDto.getAppId());//SimpleFieldAssign//sourceId:50363_1_745
                            }

                            /*1-3-13新增就职记录[162]   */
                            Assert.isNull(inductionRecord_3.getInductionUnitTypeCode(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-就职单位类型实例不能为空", false);
                            Assert.isNull(inductionRecord_3.getEntityId(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-就职单位对象实例ID不能为空", false);
                            Assert.isNull(inductionRecord_3.getOriginalRoleMemberId(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-身份人员ID不能为空", false);
                            Assert.isNull(inductionRecord_3.getUserId(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-个人账号ID不能为空", false);
                            Assert.isNull(inductionRecord_3.getFirstLetter(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-备注首位字母不能为空", false);
                            Assert.isNull(inductionRecord_3.getOrganizationId(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-组织ID不能为空", false);
                            Assert.isNull(inductionRecord_3.getOrganizationName(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-冗余组织名称不能为空", false);
                            Assert.isNull(inductionRecord_3.getPositionType(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-职务性质不能为空", false);
                            Assert.isNull(inductionRecord_3.getIsMainInduction(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-是否主岗不能为空", false);
                            Assert.isNull(inductionRecord_3.getOrderNumber(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-排序不能为空", false);
                            Assert.isNull(inductionRecord_3.getIsCustomPosition(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-是否自定义职务不能为空", false);
                            Assert.isNull(inductionRecord_3.getPositionIdName(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-必选冗余职务名称不能为空", false);
                            Assert.isNull(inductionRecord_3.getSubjectLifeCycle(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-主体生命周期不能为空", false);
                            Assert.isNull(inductionRecord_3.getIsUpdate(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-批次下是否更新不能为空", false);
                            Assert.isNull(inductionRecord_3.getUpdateStatus(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-批次下更新状态不能为空", false);
                            Assert.isNull(inductionRecord_3.getIsEditing(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-是否未来不能为空", false);
                            Assert.isNull(inductionRecord_3.getIsDirector(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-是否主管不能为空", false);
                            Assert.isNull(inductionRecord_3.getSpaceId(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-创建于空间ID不能为空", false);
                            Assert.isNull(inductionRecord_3.getAppId(), "D1-新增空间管理员角色人员（平台）-1-3-13新增就职记录-创建于联盟应用ID不能为空", false);
                            string_34 = mInductionRecordService.addInductionRecord(inductionRecord_3)/*vcase invoke 本地 method 方法调用;*/;


                        }
//processBranchName:正常结束 ,processBranchId:746

                    } else {
                        //else  747

//processBranchName:正常结束 ,processBranchId:749

                    }
                } else {
                    //else  682

//异常结束 683
                    throw new BizException("10200005", "对不起，该成员已经存在，不可以新增！", false);
                }
            }
        }
        AddAdminRoleRelRespDto retData = new AddAdminRoleRelRespDto();
        if (string_11 != null) {
            retData.setRoleMemberId(string_11);//SimpleFieldAssign//sourceId:28379_1
        }
        if (receptionServiceRes_1 != null) {
            retData.setOriginalRoleMemberId(receptionServiceRes_1.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1499890_1
            retData.setUserId(receptionServiceRes_1.getUserId());//SimpleFieldAssign//sourceId:1499891_1
        }


        return retData;
    }

    /**
     * D1-3查询去重部门员工列表[1716]
     * gen by moon at 10/2/2022, 12:22:31 AM
     */
    @Trace(operationName = "D1-3查询去重部门员工列表")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    @BanAuto
    public QueryFilterDeptSatffListRespDto queryFilterDeptSatffList(QueryFilterDeptSatffListReqDto reqDto) {


        List<OriginalRoleMember> listOriginalRoleMember_1 = new ArrayList<>();
        QueryCollectionRemoveDuplicateDataListRespDto collectionRemoveExistingDataRes_1 = null;
        List<OriginalRoleMemberInfo> listOriginalRoleMemberInfo_1 = new ArrayList<>();
        List<Userinfo> listUserinfo_3 = new ArrayList<>();
        List<OriginalRoleMember> listOriginalRoleMember_3 = new ArrayList<>();
        if ((reqDto != null && reqDto.getIdCardName() != null)) {
            //if(D1-3查询去重部门员工列表.真实姓名 不等于空 )  1791

            List<Userinfo> listUserinfo = new ArrayList<>();
            QueryUserInfoListReq queryUserInfoListReq = new QueryUserInfoListReq();
            if (reqDto != null) {
                queryUserInfoListReq.setIdCardName(reqDto.getIdCardName());//SimpleFieldAssign//sourceId:51372_1_1793
            }

            /*1-2-02查询个人资料列表（姓名搜索）[1178]   */

            listUserinfo = mUserinfoService.queryUserInfoList(queryUserInfoListReq);


            List<OriginalRoleMember> listOriginalRoleMember = new ArrayList<>();
            if (listUserinfo != null && listUserinfo.size() > 0) {
                BatchQueryStaffBeginMemberListReq batchQueryStaffBeginMemberListReq = new BatchQueryStaffBeginMemberListReq();
                batchQueryStaffBeginMemberListReq.setStaffBeginMemberList(listUserinfo.stream().map(item -> item.getUserId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:51438_1_1794
                batchQueryStaffBeginMemberListReq.setRoleCode("STAFF");//CUSTOM_CONVENTION//sourceId:51454_1_1794
                batchQueryStaffBeginMemberListReq.setIsTransaction("FALSE");//sourceId:51448_1_1794
                batchQueryStaffBeginMemberListReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:51445_1_1794
                batchQueryStaffBeginMemberListReq.setIsArchive("FALSE");//sourceId:51439_1_1794
                batchQueryStaffBeginMemberListReq.setIsInvalid("FALSE");//sourceId:51442_1_1794
                batchQueryStaffBeginMemberListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:51443_1_1794

                /*1-2-09批量查询员工身份人员列表（搜索全部员工）[1259]   */
                Assert.isNull(batchQueryStaffBeginMemberListReq.getRoleCode(), "D1-3查询去重部门员工列表-1-2-09批量查询员工身份人员列表（搜索全部员工）-身份角色编码不能为空", false);
                Assert.isNull(batchQueryStaffBeginMemberListReq.getIsTransaction(), "D1-3查询去重部门员工列表-1-2-09批量查询员工身份人员列表（搜索全部员工）-是否异动不能为空", false);
                Assert.isNull(batchQueryStaffBeginMemberListReq.getSubjectLifeCycle(), "D1-3查询去重部门员工列表-1-2-09批量查询员工身份人员列表（搜索全部员工）-主体生命周期不能为空", false);
                Assert.isNull(batchQueryStaffBeginMemberListReq.getIsArchive(), "D1-3查询去重部门员工列表-1-2-09批量查询员工身份人员列表（搜索全部员工）-是否存档不能为空", false);
                Assert.isNull(batchQueryStaffBeginMemberListReq.getIsInvalid(), "D1-3查询去重部门员工列表-1-2-09批量查询员工身份人员列表（搜索全部员工）-是否失效不能为空", false);
                Assert.isNull(batchQueryStaffBeginMemberListReq.getSpaceId(), "D1-3查询去重部门员工列表-1-2-09批量查询员工身份人员列表（搜索全部员工）-创建于空间ID不能为空", false);
                listOriginalRoleMember = mOriginalRoleMemberService.batchQueryStaffBeginMemberList(batchQueryStaffBeginMemberListReq);


                listOriginalRoleMember_1 = listOriginalRoleMember;
            }
            List<InductionRecord> listInductionRecord = new ArrayList<>();
            QueryInductionRecordListReq queryInductionRecordListReq = new QueryInductionRecordListReq();
            queryInductionRecordListReq.setIsArchive("FALSE");//sourceId:51490_1_1795
            if (reqDto != null) {
                queryInductionRecordListReq.setInductionUnitTypeCode(reqDto.getInductionUnitTypeCode());//SimpleFieldAssign//sourceId:51456_1_1795
                queryInductionRecordListReq.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:51463_1_1795
            }

            /*1-3-13查询就职记录列表[166]   */
            Assert.isNull(queryInductionRecordListReq.getInductionUnitTypeCode(), "D1-3查询去重部门员工列表-1-3-13查询就职记录列表-就职单位类型实例不能为空", false);
            Assert.isNull(queryInductionRecordListReq.getEntityId(), "D1-3查询去重部门员工列表-1-3-13查询就职记录列表-就职单位对象实例ID不能为空", false);
            Assert.isNull(queryInductionRecordListReq.getIsArchive(), "D1-3查询去重部门员工列表-1-3-13查询就职记录列表-是否存档不能为空", false);
            listInductionRecord = mInductionRecordService.queryInductionRecordList(queryInductionRecordListReq);


//ModelCode: collectionRemoveExistingData
            QueryCollectionRemoveDuplicateDataListRespDto collectionRemoveExistingDataRes = null;
            if (listOriginalRoleMember != null && listOriginalRoleMember.size() > 0) {
                QueryCollectionRemoveDuplicateDataListReqDto collectionRemoveExistingDataReq = new QueryCollectionRemoveDuplicateDataListReqDto();
                collectionRemoveExistingDataReq.setBeginMemberList(listOriginalRoleMember.stream().map(item -> {
                    BeginMemberDto elm = BeanUtil.toBean(item, BeginMemberDto.class);
                    //elm.setOriginalRoleMemberId();//DUPLICATE_ID  TODO ruizhe dong

                    return elm;
                }).collect(Collectors.toList()));//objList-to-objLists//sourceId:51503_1_1805
                collectionRemoveExistingDataReq.setOrgInductionRecordList(listInductionRecord.stream().map(item -> item.getOriginalRoleMemberId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:51502_1_1805

                /*M-查询去重部门员工列表（特殊方法）[1715]  入参两个数据集，通过已存在标识字段匹配，去除第一个数据集中已存在的第二个数据集的数据 */

                collectionRemoveExistingDataRes = nbMember.queryCollectionRemoveDuplicateDataList(collectionRemoveExistingDataReq);


                collectionRemoveExistingDataRes_1 = collectionRemoveExistingDataRes;
            }
            List<OriginalRoleMemberInfo> listOriginalRoleMemberInfo = new ArrayList<>();
            BatchQueryBeginMembInfoListReq batchQueryBeginMembInfoListReq = new BatchQueryBeginMembInfoListReq();
            if (collectionRemoveExistingDataRes != null) {
                batchQueryBeginMembInfoListReq.setBeginMembInfoList(collectionRemoveExistingDataRes.getBeginMemberList().stream().map(item -> item.getOriginalRoleMemberId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:51494_1_1806
            }

            /*1-2-10批量查询身份人员资料列表[1014]   */

            listOriginalRoleMemberInfo = mOriginalRoleMemberInfoService.batchQueryBeginMembInfoList(batchQueryBeginMembInfoListReq);


            listOriginalRoleMemberInfo_1 = listOriginalRoleMemberInfo;
            List<Userinfo> listUserinfo_2 = new ArrayList<>();
            BatchQueryUserinfoListReq batchQueryUserinfoListReq = new BatchQueryUserinfoListReq();
            if (collectionRemoveExistingDataRes != null) {
                batchQueryUserinfoListReq.setUserList(collectionRemoveExistingDataRes.getBeginMemberList().stream().map(item -> item.getUserId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:51495_1_1807
            }

            /*1-2-02批量查询个人资料列表[52]   */

            listUserinfo_2 = mUserinfoService.batchQueryUserinfoList(batchQueryUserinfoListReq);


            listUserinfo_3 = listUserinfo_2;
//processBranchName:正常结束 ,processBranchId:1811

        } else {
            //else  1792

            List<OriginalRoleMember> listOriginalRoleMember_2 = new ArrayList<>();
            QueryBeginMemberListReq queryBeginMemberListReq = new QueryBeginMemberListReq();
            queryBeginMemberListReq.setRoleCode("STAFF");//CUSTOM_CONVENTION//sourceId:51387_1_1799
            queryBeginMemberListReq.setIsTransaction("FALSE");//sourceId:51394_1_1799
            queryBeginMemberListReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:51386_1_1799
            queryBeginMemberListReq.setIsArchive("FALSE");//sourceId:51388_1_1799
            queryBeginMemberListReq.setIsInvalid("FALSE");//sourceId:51390_1_1799
            queryBeginMemberListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:51385_1_1799

            /*1-2-09查询身份人员列表[80]   */
            Assert.isNull(queryBeginMemberListReq.getRoleCode(), "D1-3查询去重部门员工列表-1-2-09查询身份人员列表-身份角色编码不能为空", false);
            Assert.isNull(queryBeginMemberListReq.getIsTransaction(), "D1-3查询去重部门员工列表-1-2-09查询身份人员列表-是否异动不能为空", false);
            Assert.isNull(queryBeginMemberListReq.getSubjectLifeCycle(), "D1-3查询去重部门员工列表-1-2-09查询身份人员列表-主体生命周期不能为空", false);
            Assert.isNull(queryBeginMemberListReq.getIsArchive(), "D1-3查询去重部门员工列表-1-2-09查询身份人员列表-是否存档不能为空", false);
            Assert.isNull(queryBeginMemberListReq.getIsInvalid(), "D1-3查询去重部门员工列表-1-2-09查询身份人员列表-是否失效不能为空", false);
            Assert.isNull(queryBeginMemberListReq.getSpaceId(), "D1-3查询去重部门员工列表-1-2-09查询身份人员列表-创建于空间ID不能为空", false);
            listOriginalRoleMember_2 = mOriginalRoleMemberService.queryBeginMemberList(queryBeginMemberListReq);


            listOriginalRoleMember_3 = listOriginalRoleMember_2;
            List<InductionRecord> listInductionRecord_2 = new ArrayList<>();
            QueryInductionRecordListReq queryInductionRecordListReq_1 = new QueryInductionRecordListReq();
            queryInductionRecordListReq_1.setIsArchive("FALSE");//sourceId:51490_1_1800
            if (reqDto != null) {
                queryInductionRecordListReq_1.setInductionUnitTypeCode(reqDto.getInductionUnitTypeCode());//SimpleFieldAssign//sourceId:51456_1_1800
                queryInductionRecordListReq_1.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:51463_1_1800
            }

            /*1-3-13查询就职记录列表[166]   */
            Assert.isNull(queryInductionRecordListReq_1.getInductionUnitTypeCode(), "D1-3查询去重部门员工列表-1-3-13查询就职记录列表-就职单位类型实例不能为空", false);
            Assert.isNull(queryInductionRecordListReq_1.getEntityId(), "D1-3查询去重部门员工列表-1-3-13查询就职记录列表-就职单位对象实例ID不能为空", false);
            Assert.isNull(queryInductionRecordListReq_1.getIsArchive(), "D1-3查询去重部门员工列表-1-3-13查询就职记录列表-是否存档不能为空", false);
            listInductionRecord_2 = mInductionRecordService.queryInductionRecordList(queryInductionRecordListReq_1);


//ModelCode: collectionRemoveExistingData
            QueryCollectionRemoveDuplicateDataListRespDto collectionRemoveExistingDataRes_2 = null;
            if (listOriginalRoleMember_2 != null && listOriginalRoleMember_2.size() > 0) {
                QueryCollectionRemoveDuplicateDataListReqDto collectionRemoveExistingDataReq_1 = new QueryCollectionRemoveDuplicateDataListReqDto();
                collectionRemoveExistingDataReq_1.setBeginMemberList(listOriginalRoleMember_2.stream().map(item -> {
                    BeginMemberDto elm = BeanUtil.toBean(item, BeginMemberDto.class);
                    //elm.setOriginalRoleMemberId();//DUPLICATE_ID  TODO ruizhe dong

                    return elm;
                }).collect(Collectors.toList()));//objList-to-objLists//sourceId:51503_1_1808
                collectionRemoveExistingDataReq_1.setOrgInductionRecordList(listInductionRecord_2.stream().map(item -> item.getOriginalRoleMemberId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:51502_1_1808

                /*M-查询去重部门员工列表（特殊方法）[1715]  入参两个数据集，通过已存在标识字段匹配，去除第一个数据集中已存在的第二个数据集的数据 */

                collectionRemoveExistingDataRes_2 = nbMember.queryCollectionRemoveDuplicateDataList(collectionRemoveExistingDataReq_1);


                collectionRemoveExistingDataRes_1 = collectionRemoveExistingDataRes_2;
            }
            List<OriginalRoleMemberInfo> listOriginalRoleMemberInfo_2 = new ArrayList<>();
            BatchQueryBeginMembInfoListReq batchQueryBeginMembInfoListReq_1 = new BatchQueryBeginMembInfoListReq();
            if (collectionRemoveExistingDataRes_2 != null) {
                batchQueryBeginMembInfoListReq_1.setBeginMembInfoList(collectionRemoveExistingDataRes_2.getBeginMemberList().stream().map(item -> item.getOriginalRoleMemberId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:51494_1_1809
            }

            /*1-2-10批量查询身份人员资料列表[1014]   */

            listOriginalRoleMemberInfo_2 = mOriginalRoleMemberInfoService.batchQueryBeginMembInfoList(batchQueryBeginMembInfoListReq_1);


            listOriginalRoleMemberInfo_1 = listOriginalRoleMemberInfo_2;
            List<Userinfo> listUserinfo_4 = new ArrayList<>();
            BatchQueryUserinfoListReq batchQueryUserinfoListReq_1 = new BatchQueryUserinfoListReq();
            if (collectionRemoveExistingDataRes_2 != null) {
                batchQueryUserinfoListReq_1.setUserList(collectionRemoveExistingDataRes_2.getBeginMemberList().stream().map(item -> item.getUserId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:51495_1_1810
            }

            /*1-2-02批量查询个人资料列表[52]   */

            listUserinfo_4 = mUserinfoService.batchQueryUserinfoList(batchQueryUserinfoListReq_1);


            listUserinfo_3 = listUserinfo_4;
//processBranchName:正常结束 ,processBranchId:1812

        }
        QueryFilterDeptSatffListRespDto retData = new QueryFilterDeptSatffListRespDto();
        //数据集融合  MoreListToOneSource
        if (collectionRemoveExistingDataRes_1 != null && !CollectionUtil.isEmpty(collectionRemoveExistingDataRes_1.getBeginMemberList())) {
            for (BeginMemberDto beginMemberDto : collectionRemoveExistingDataRes_1.getBeginMemberList()) {
                StaffBeginMemberDto retElm = new StaffBeginMemberDto();
                if (collectionRemoveExistingDataRes_1 != null) {
                    retElm.setOriginalRoleMemberId(beginMemberDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:27081_2
                    retElm.setUserId(beginMemberDto.getUserId());//SimpleFieldAssign//sourceId:27082_2
                    retElm.setFirstLetter(beginMemberDto.getFirstLetter());//SimpleFieldAssign//sourceId:27083_2
                }
                retData.getStaffBeginMemberList().add(retElm);
                if (listOriginalRoleMemberInfo_1 != null) {
                    for (OriginalRoleMemberInfo originalRoleMemberInfo : listOriginalRoleMemberInfo_1) {
                        if (originalRoleMemberInfo.getOriginalRoleMemberId().equals(beginMemberDto.getOriginalRoleMemberId())) {
                            retElm.setRoleMemberCode(originalRoleMemberInfo.getRoleMemberCode());//SimpleFieldAssign//sourceId:27084_2
                            retElm.setPositionIdName(originalRoleMemberInfo.getPositionIdName());//SimpleFieldAssign//sourceId:27087_2
                            retElm.setIsPtJob(originalRoleMemberInfo.getIsPtJob());//SimpleFieldAssign//sourceId:27212_2
                        }
                    }
                }

                if (listUserinfo_3 != null) {
                    for (Userinfo userinfo : listUserinfo_3) {
                        if (userinfo.getUserId().equals(beginMemberDto.getUserId())) {
                            retElm.setIdCardName(userinfo.getIdCardName());//SimpleFieldAssign//sourceId:27085_2
                            retElm.setNickName(userinfo.getNickName());//SimpleFieldAssign//sourceId:27086_2
                            retElm.setUserFace(userinfo.getUserFace());//SimpleFieldAssign//sourceId:27088_2
                        }
                    }
                }

            }
        }//sourceId:51498_1


        return retData;
    }

    /**
     * D1-2查询员工去重角色人员列表（边界）[1701]
     * gen by moon at 10/2/2022, 12:21:03 AM
     */
    @Trace(operationName = "D1-2查询员工去重角色人员列表（边界）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryStaffFilterRoleRelListBorderRespDto queryStaffFilterRoleRelListBorder(QueryStaffFilterRoleRelListBorderReqDto reqDto) {


        List<OriginalRoleMember> listOriginalRoleMember_3 = new ArrayList<>();
        List<OriginalRoleMemberInfo> listOriginalRoleMemberInfo_1 = new ArrayList<>();
        List<Userinfo> listUserinfo_3 = new ArrayList<>();
        if ((reqDto != null && reqDto.getIdCardName() != null)) {
            //if(D1-2查询员工去重角色人员列表（边界）.真实姓名 不等于空 )  1679

            List<Userinfo> listUserinfo = new ArrayList<>();
            QueryUserInfoListReq queryUserInfoListReq = new QueryUserInfoListReq();
            if (reqDto != null) {
                queryUserInfoListReq.setIdCardName(reqDto.getIdCardName());//SimpleFieldAssign//sourceId:50811_1_1680
            }

            /*1-2-02查询个人资料列表（姓名查询）[1178]   */

            listUserinfo = mUserinfoService.queryUserInfoList(queryUserInfoListReq);


            List<OriginalRoleMember> listOriginalRoleMember = new ArrayList<>();
            if (listUserinfo != null && listUserinfo.size() > 0) {
                BatchQueryStaffBeginMemberListReq batchQueryStaffBeginMemberListReq = new BatchQueryStaffBeginMemberListReq();
                batchQueryStaffBeginMemberListReq.setStaffBeginMemberList(listUserinfo.stream().map(item -> item.getUserId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:50815_1_1681
                batchQueryStaffBeginMemberListReq.setRoleCode("STAFF");//CUSTOM_CONVENTION//sourceId:51541_1_1681
                batchQueryStaffBeginMemberListReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:50973_1_1681
                batchQueryStaffBeginMemberListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:50832_1_1681

                /*1-2-09批量查询员工身份人员列表（查全部员工）[1259]   */
                Assert.isNull(batchQueryStaffBeginMemberListReq.getRoleCode(), "D1-2查询员工去重角色人员列表（边界）-1-2-09批量查询员工身份人员列表（查全部员工）-身份角色编码不能为空", false);
                Assert.isNull(batchQueryStaffBeginMemberListReq.getSubjectLifeCycle(), "D1-2查询员工去重角色人员列表（边界）-1-2-09批量查询员工身份人员列表（查全部员工）-主体生命周期不能为空", false);
                Assert.isNull(batchQueryStaffBeginMemberListReq.getSpaceId(), "D1-2查询员工去重角色人员列表（边界）-1-2-09批量查询员工身份人员列表（查全部员工）-创建于空间ID不能为空", false);
                listOriginalRoleMember = mOriginalRoleMemberService.batchQueryStaffBeginMemberList(batchQueryStaffBeginMemberListReq);


            }
            List<RoleMember> listRoleMember = new ArrayList<>();
            QueryRoleRelListReq queryRoleRelListReq = new QueryRoleRelListReq();
            queryRoleRelListReq.setRelationshipValid("FALSE");//sourceId:51062_1_1682
            queryRoleRelListReq.setIsArchive("FALSE");//sourceId:50734_1_1682
            queryRoleRelListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:50754_1_1682
            if (reqDto != null) {
                queryRoleRelListReq.setRoleCode(reqDto.getRoleCode());//SimpleFieldAssign//sourceId:50732_1_1682
            }

            /*1-2-13查询角色人员列表（查已有角色人员）[334]   */
            Assert.isNull(queryRoleRelListReq.getRoleCode(), "D1-2查询员工去重角色人员列表（边界）-1-2-13查询角色人员列表（查已有角色人员）-角色标识不能为空", false);
            Assert.isNull(queryRoleRelListReq.getRelationshipValid(), "D1-2查询员工去重角色人员列表（边界）-1-2-13查询角色人员列表（查已有角色人员）-是否失效不能为空", false);
            Assert.isNull(queryRoleRelListReq.getIsArchive(), "D1-2查询员工去重角色人员列表（边界）-1-2-13查询角色人员列表（查已有角色人员）-是否存档不能为空", false);
            Assert.isNull(queryRoleRelListReq.getSpaceId(), "D1-2查询员工去重角色人员列表（边界）-1-2-13查询角色人员列表（查已有角色人员）-创建于空间ID不能为空", false);
            listRoleMember = mRoleMemberService.queryRoleRelList(queryRoleRelListReq);


//ModelCode: collectionRemoveExistingData
            QueryCollectionRemoveExistingDataListRespDto collectionRemoveExistingDataRes = null;
            if (listOriginalRoleMember != null && listOriginalRoleMember.size() > 0) {
                QueryCollectionRemoveExistingDataListReqDto collectionRemoveExistingDataReq = new QueryCollectionRemoveExistingDataListReqDto();
                collectionRemoveExistingDataReq.setStaffBeginMemberList(listOriginalRoleMember.stream().map(item -> item.getOriginalRoleMemberId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:50721_1_1683
                collectionRemoveExistingDataReq.setRoleRelList(listRoleMember.stream().map(item -> item.getOriginalRoleMemberId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:50720_1_1683

                /*查询可用空间管理员（合并去除重复特殊方法）[1541]  入参两个数据集，通过已存在标识字段匹配，去除第一个数据集中已存在的第二个数据集的数据 */

                collectionRemoveExistingDataRes = nbMember.queryCollectionRemoveExistingDataList(collectionRemoveExistingDataReq);


            }
            List<OriginalRoleMember> listOriginalRoleMember_2 = new ArrayList<>();
            BatchQueryBeginMemberListReq batchQueryBeginMemberListReq = new BatchQueryBeginMemberListReq();
            batchQueryBeginMemberListReq.setRoleCode("STAFF");//CUSTOM_CONVENTION//sourceId:51543_1_1684
            batchQueryBeginMemberListReq.setIsTransaction("FALSE");//sourceId:50906_1_1684
            batchQueryBeginMemberListReq.setIsInvalid("FALSE");//sourceId:50870_1_1684
            if (collectionRemoveExistingDataRes != null) {
                //list-field-assign
                batchQueryBeginMemberListReq.setBeginMemberList(collectionRemoveExistingDataRes.getStaffBeginMemberList());//sourceId:50723_1_1684
            }

            /*1-2-09批量查询身份人员列表（确定主体入参）[1181]   */
            Assert.isNull(batchQueryBeginMemberListReq.getRoleCode(), "D1-2查询员工去重角色人员列表（边界）-1-2-09批量查询身份人员列表（确定主体入参）-身份角色编码不能为空", false);
            Assert.isNull(batchQueryBeginMemberListReq.getIsTransaction(), "D1-2查询员工去重角色人员列表（边界）-1-2-09批量查询身份人员列表（确定主体入参）-是否异动不能为空", false);
            Assert.isNull(batchQueryBeginMemberListReq.getIsInvalid(), "D1-2查询员工去重角色人员列表（边界）-1-2-09批量查询身份人员列表（确定主体入参）-是否失效不能为空", false);
            listOriginalRoleMember_2 = mOriginalRoleMemberService.batchQueryBeginMemberList(batchQueryBeginMemberListReq);


            listOriginalRoleMember_3 = listOriginalRoleMember_2;
            List<OriginalRoleMemberInfo> listOriginalRoleMemberInfo = new ArrayList<>();
            if (listOriginalRoleMember_2 != null && listOriginalRoleMember_2.size() > 0) {
                BatchQueryBeginMembInfoListReq batchQueryBeginMembInfoListReq = new BatchQueryBeginMembInfoListReq();
                batchQueryBeginMembInfoListReq.setBeginMembInfoList(listOriginalRoleMember_2.stream().map(item -> item.getOriginalRoleMemberId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:50729_1_1685

                /*1-2-10批量查询身份人员资料列表[1014]   */

                listOriginalRoleMemberInfo = mOriginalRoleMemberInfoService.batchQueryBeginMembInfoList(batchQueryBeginMembInfoListReq);


                listOriginalRoleMemberInfo_1 = listOriginalRoleMemberInfo;
            }
            List<Userinfo> listUserinfo_2 = new ArrayList<>();
            if (listOriginalRoleMember_2 != null && listOriginalRoleMember_2.size() > 0) {
                BatchQueryUserinfoListReq batchQueryUserinfoListReq = new BatchQueryUserinfoListReq();
                batchQueryUserinfoListReq.setUserList(listOriginalRoleMember_2.stream().map(item -> item.getUserId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:50730_1_1686

                /*1-2-02批量查询个人资料列表[52]   */

                listUserinfo_2 = mUserinfoService.batchQueryUserinfoList(batchQueryUserinfoListReq);


                listUserinfo_3 = listUserinfo_2;
            }
//processBranchName:正常结束 ,processBranchId:1687

        } else {
            //else  1688

            List<OriginalRoleMember> listOriginalRoleMember_4 = new ArrayList<>();
            QueryBeginMemberListReq queryBeginMemberListReq = new QueryBeginMemberListReq();
            queryBeginMemberListReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:50967_1_1689
            queryBeginMemberListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:50968_1_1689

            /*1-2-09查询身份人员列表[80]   */
            Assert.isNull(queryBeginMemberListReq.getSubjectLifeCycle(), "D1-2查询员工去重角色人员列表（边界）-1-2-09查询身份人员列表-主体生命周期不能为空", false);
            Assert.isNull(queryBeginMemberListReq.getSpaceId(), "D1-2查询员工去重角色人员列表（边界）-1-2-09查询身份人员列表-创建于空间ID不能为空", false);
            listOriginalRoleMember_4 = mOriginalRoleMemberService.queryBeginMemberList(queryBeginMemberListReq);


            List<RoleMember> listRoleMember_2 = new ArrayList<>();
            QueryRoleRelListReq queryRoleRelListReq_1 = new QueryRoleRelListReq();
            queryRoleRelListReq_1.setRelationshipValid("FALSE");//sourceId:51062_1_1690
            queryRoleRelListReq_1.setIsArchive("FALSE");//sourceId:50734_1_1690
            queryRoleRelListReq_1.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:50754_1_1690
            if (reqDto != null) {
                queryRoleRelListReq_1.setRoleCode(reqDto.getRoleCode());//SimpleFieldAssign//sourceId:50732_1_1690
            }

            /*1-2-13查询角色人员列表（查已有角色人员）[334]   */
            Assert.isNull(queryRoleRelListReq_1.getRoleCode(), "D1-2查询员工去重角色人员列表（边界）-1-2-13查询角色人员列表（查已有角色人员）-角色标识不能为空", false);
            Assert.isNull(queryRoleRelListReq_1.getRelationshipValid(), "D1-2查询员工去重角色人员列表（边界）-1-2-13查询角色人员列表（查已有角色人员）-是否失效不能为空", false);
            Assert.isNull(queryRoleRelListReq_1.getIsArchive(), "D1-2查询员工去重角色人员列表（边界）-1-2-13查询角色人员列表（查已有角色人员）-是否存档不能为空", false);
            Assert.isNull(queryRoleRelListReq_1.getSpaceId(), "D1-2查询员工去重角色人员列表（边界）-1-2-13查询角色人员列表（查已有角色人员）-创建于空间ID不能为空", false);
            listRoleMember_2 = mRoleMemberService.queryRoleRelList(queryRoleRelListReq_1);


//ModelCode: collectionRemoveExistingData
            QueryCollectionRemoveExistingDataListRespDto collectionRemoveExistingDataRes_2 = null;
            if (listOriginalRoleMember_4 != null && listOriginalRoleMember_4.size() > 0) {
                QueryCollectionRemoveExistingDataListReqDto collectionRemoveExistingDataReq_1 = new QueryCollectionRemoveExistingDataListReqDto();
                collectionRemoveExistingDataReq_1.setStaffBeginMemberList(listOriginalRoleMember_4.stream().map(item -> item.getOriginalRoleMemberId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:50721_1_1691
                collectionRemoveExistingDataReq_1.setRoleRelList(listRoleMember_2.stream().map(item -> item.getOriginalRoleMemberId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:50720_1_1691

                /*查询可用空间管理员（合并去除重复特殊方法）[1541]  入参两个数据集，通过已存在标识字段匹配，去除第一个数据集中已存在的第二个数据集的数据 */

                collectionRemoveExistingDataRes_2 = nbMember.queryCollectionRemoveExistingDataList(collectionRemoveExistingDataReq_1);


            }
            List<OriginalRoleMember> listOriginalRoleMember_6 = new ArrayList<>();
            BatchQueryBeginMemberListReq batchQueryBeginMemberListReq_1 = new BatchQueryBeginMemberListReq();
            batchQueryBeginMemberListReq_1.setRoleCode("STAFF");//CUSTOM_CONVENTION//sourceId:51543_1_1692
            batchQueryBeginMemberListReq_1.setIsTransaction("FALSE");//sourceId:50906_1_1692
            batchQueryBeginMemberListReq_1.setIsInvalid("FALSE");//sourceId:50870_1_1692
            if (collectionRemoveExistingDataRes_2 != null) {
                //list-field-assign
                batchQueryBeginMemberListReq_1.setBeginMemberList(collectionRemoveExistingDataRes_2.getStaffBeginMemberList());//sourceId:50723_1_1692
            }

            /*1-2-09批量查询身份人员列表（确定主体入参）[1181]   */
            Assert.isNull(batchQueryBeginMemberListReq_1.getRoleCode(), "D1-2查询员工去重角色人员列表（边界）-1-2-09批量查询身份人员列表（确定主体入参）-身份角色编码不能为空", false);
            Assert.isNull(batchQueryBeginMemberListReq_1.getIsTransaction(), "D1-2查询员工去重角色人员列表（边界）-1-2-09批量查询身份人员列表（确定主体入参）-是否异动不能为空", false);
            Assert.isNull(batchQueryBeginMemberListReq_1.getIsInvalid(), "D1-2查询员工去重角色人员列表（边界）-1-2-09批量查询身份人员列表（确定主体入参）-是否失效不能为空", false);
            listOriginalRoleMember_6 = mOriginalRoleMemberService.batchQueryBeginMemberList(batchQueryBeginMemberListReq_1);


            listOriginalRoleMember_3 = listOriginalRoleMember_6;
            List<OriginalRoleMemberInfo> listOriginalRoleMemberInfo_2 = new ArrayList<>();
            if (listOriginalRoleMember_6 != null && listOriginalRoleMember_6.size() > 0) {
                BatchQueryBeginMembInfoListReq batchQueryBeginMembInfoListReq_1 = new BatchQueryBeginMembInfoListReq();
                batchQueryBeginMembInfoListReq_1.setBeginMembInfoList(listOriginalRoleMember_6.stream().map(item -> item.getOriginalRoleMemberId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:50729_1_1693

                /*1-2-10批量查询身份人员资料列表[1014]   */

                listOriginalRoleMemberInfo_2 = mOriginalRoleMemberInfoService.batchQueryBeginMembInfoList(batchQueryBeginMembInfoListReq_1);


                listOriginalRoleMemberInfo_1 = listOriginalRoleMemberInfo_2;
            }
            List<Userinfo> listUserinfo_4 = new ArrayList<>();
            if (listOriginalRoleMember_6 != null && listOriginalRoleMember_6.size() > 0) {
                BatchQueryUserinfoListReq batchQueryUserinfoListReq_1 = new BatchQueryUserinfoListReq();
                batchQueryUserinfoListReq_1.setUserList(listOriginalRoleMember_6.stream().map(item -> item.getUserId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:50730_1_1694

                /*1-2-02批量查询个人资料列表[52]   */

                listUserinfo_4 = mUserinfoService.batchQueryUserinfoList(batchQueryUserinfoListReq_1);


                listUserinfo_3 = listUserinfo_4;
            }
//processBranchName:正常结束 ,processBranchId:1695

        }
        QueryStaffFilterRoleRelListBorderRespDto retData = new QueryStaffFilterRoleRelListBorderRespDto();
        //数据集融合  MoreListToOneSource
        if (listOriginalRoleMember_3 != null && !CollectionUtil.isEmpty(listOriginalRoleMember_3)) {
            for (OriginalRoleMember originalRoleMember : listOriginalRoleMember_3) {
                BeginMemberDto retElm = new BeginMemberDto();
                retElm.setOriginalRoleMemberId(originalRoleMember.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:26547_2
                retElm.setFirstLetter(originalRoleMember.getFirstLetter());//SimpleFieldAssign//sourceId:26553_2
                retElm.setUserId(originalRoleMember.getUserId());//SimpleFieldAssign//sourceId:26549_2
                retData.getBeginMemberList().add(retElm);
                if (listOriginalRoleMemberInfo_1 != null) {
                    for (OriginalRoleMemberInfo originalRoleMemberInfo : listOriginalRoleMemberInfo_1) {
                        if (originalRoleMemberInfo.getOriginalRoleMemberId().equals(originalRoleMember.getOriginalRoleMemberId())) {
                            retElm.setRoleMemberCode(originalRoleMemberInfo.getRoleMemberCode());//SimpleFieldAssign//sourceId:26551_2
                            retElm.setPositionIdName(originalRoleMemberInfo.getPositionIdName());//SimpleFieldAssign//sourceId:26552_2
                            retElm.setIsPtJob(originalRoleMemberInfo.getIsPtJob());//SimpleFieldAssign//sourceId:26554_2
                        }
                    }
                }

                if (listUserinfo_3 != null) {
                    for (Userinfo userinfo : listUserinfo_3) {
                        if (userinfo.getUserId().equals(originalRoleMember.getUserId())) {
                            retElm.setUserFace(userinfo.getUserFace());//SimpleFieldAssign//sourceId:26546_2
                            retElm.setIdCardName(userinfo.getIdCardName());//SimpleFieldAssign//sourceId:26548_2
                            retElm.setNickName(userinfo.getNickName());//SimpleFieldAssign//sourceId:26550_2
                        }
                    }
                }

            }
        }//sourceId:51007_1


        return retData;
    }

    /**
     * D1-3查询组织员工列表（边界）[1585]
     * gen by moon at 10/2/2022, 12:13:36 AM
     */
    @Trace(operationName = "D1-3查询组织员工列表（边界）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryOrgStaffListRespDto queryOrgStaffList(QueryOrgStaffListReqDto reqDto) {


        List<OriginalRoleMember> listOriginalRoleMember_3 = new ArrayList<>();
        List<OriginalRoleMemberInfo> listOriginalRoleMemberInfo_1 = new ArrayList<>();
        List<Userinfo> listUserinfo_1 = new ArrayList<>();
//步骤0: 1-2-09查询身份人员列表 - queryBeginMemberList
        List<OriginalRoleMember> listOriginalRoleMember = new ArrayList<>();
        QueryBeginMemberListReq queryBeginMemberListReq = new QueryBeginMemberListReq();
        queryBeginMemberListReq.setRoleCode("STAFF");//CUSTOM_CONVENTION//sourceId:63321_1
        queryBeginMemberListReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:45942_1
        queryBeginMemberListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:45944_1

        /*1-2-09查询身份人员列表（查空间所有员工）[80]   */
        Assert.isNull(queryBeginMemberListReq.getRoleCode(), "D1-3查询组织员工列表（边界）-1-2-09查询身份人员列表（查空间所有员工）-身份角色编码不能为空", false);
        Assert.isNull(queryBeginMemberListReq.getSubjectLifeCycle(), "D1-3查询组织员工列表（边界）-1-2-09查询身份人员列表（查空间所有员工）-主体生命周期不能为空", false);
        Assert.isNull(queryBeginMemberListReq.getSpaceId(), "D1-3查询组织员工列表（边界）-1-2-09查询身份人员列表（查空间所有员工）-创建于空间ID不能为空", false);
        listOriginalRoleMember = mOriginalRoleMemberService.queryBeginMemberList(queryBeginMemberListReq);


//步骤1: 1-3-13批量查询员工就职记录列表（边界） - batchQueryStaffInductionRecord
        List<InductionRecord> listInductionRecord = new ArrayList<>();
        if (listOriginalRoleMember != null && listOriginalRoleMember.size() > 0) {
            BatchQueryStaffInductionRecordReq batchQueryStaffInductionRecordReq = new BatchQueryStaffInductionRecordReq();
            batchQueryStaffInductionRecordReq.setOrgInductionRecordList(listOriginalRoleMember.stream().map(item -> item.getOriginalRoleMemberId())
                    .collect(Collectors.toList()));/*list-to-strings*///sourceId:45934_1
            batchQueryStaffInductionRecordReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:45935_1
            if (reqDto != null) {
                batchQueryStaffInductionRecordReq.setOrganizationId(reqDto.getOrganizationId());//SimpleFieldAssign//sourceId:45936_1
            }

            /*1-3-13批量查询员工就职记录列表（查组织下员工所有就职记录）[1586] 通过组织ID查询就职记录列表，过滤非当前组织的员工  */
            Assert.isNull(batchQueryStaffInductionRecordReq.getSubjectLifeCycle(), "D1-3查询组织员工列表（边界）-1-3-13批量查询员工就职记录列表（查组织下员工所有就职记录）-主体生命周期不能为空", false);
            Assert.isNull(batchQueryStaffInductionRecordReq.getOrganizationId(), "D1-3查询组织员工列表（边界）-1-3-13批量查询员工就职记录列表（查组织下员工所有就职记录）-组织ID不能为空", false);
            listInductionRecord = mInductionRecordService.batchQueryStaffInductionRecord(batchQueryStaffInductionRecordReq);


        }

//步骤2: 1-2-09批量查询身份人员列表	 - batchQueryBeginMemberList
        List<OriginalRoleMember> listOriginalRoleMember_2 = new ArrayList<>();
        if (listInductionRecord != null && listInductionRecord.size() > 0) {
            BatchQueryBeginMemberListReq batchQueryBeginMemberListReq = new BatchQueryBeginMemberListReq();
            batchQueryBeginMemberListReq.setBeginMemberList(listInductionRecord.stream().map(item -> item.getOriginalRoleMemberId())
                    .collect(Collectors.toList()));/*list-to-strings*///sourceId:46372_1
            batchQueryBeginMemberListReq.setIsInvalid("FALSE");//sourceId:46375_1
            batchQueryBeginMemberListReq.setIsTransaction("FALSE");//sourceId:51023_1
            batchQueryBeginMemberListReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:46376_1

            /*1-2-09批量查询身份人员列表	[1181]   */
            Assert.isNull(batchQueryBeginMemberListReq.getIsInvalid(), "D1-3查询组织员工列表（边界）-1-2-09批量查询身份人员列表	-是否失效不能为空", false);
            Assert.isNull(batchQueryBeginMemberListReq.getIsTransaction(), "D1-3查询组织员工列表（边界）-1-2-09批量查询身份人员列表	-是否异动不能为空", false);
            Assert.isNull(batchQueryBeginMemberListReq.getSubjectLifeCycle(), "D1-3查询组织员工列表（边界）-1-2-09批量查询身份人员列表	-主体生命周期不能为空", false);
            listOriginalRoleMember_2 = mOriginalRoleMemberService.batchQueryBeginMemberList(batchQueryBeginMemberListReq);


            listOriginalRoleMember_3 = listOriginalRoleMember_2;
        }

//步骤3: 1-2-10批量查询身份人员资料列表 - batchQueryBeginMembInfoList
        List<OriginalRoleMemberInfo> listOriginalRoleMemberInfo = new ArrayList<>();
        if (listOriginalRoleMember_2 != null && listOriginalRoleMember_2.size() > 0) {
            BatchQueryBeginMembInfoListReq batchQueryBeginMembInfoListReq = new BatchQueryBeginMembInfoListReq();
            batchQueryBeginMembInfoListReq.setBeginMembInfoList(listOriginalRoleMember_2.stream().map(item -> item.getOriginalRoleMemberId())
                    .collect(Collectors.toList()));/*list-to-strings*///sourceId:45946_1

            /*1-2-10批量查询身份人员资料列表（合并工号等）[1014]   */

            listOriginalRoleMemberInfo = mOriginalRoleMemberInfoService.batchQueryBeginMembInfoList(batchQueryBeginMembInfoListReq);


            listOriginalRoleMemberInfo_1 = listOriginalRoleMemberInfo;
        }

//步骤4: 1-2-02批量查询个人资料列表 - batchQueryUserinfoList
        List<Userinfo> listUserinfo = new ArrayList<>();
        if (listOriginalRoleMember_2 != null && listOriginalRoleMember_2.size() > 0) {
            BatchQueryUserinfoListReq batchQueryUserinfoListReq = new BatchQueryUserinfoListReq();
            batchQueryUserinfoListReq.setUserList(listOriginalRoleMember_2.stream().map(item -> item.getUserId())
                    .collect(Collectors.toList()));/*list-to-strings*///sourceId:45947_1

            /*1-2-02批量查询个人资料列表（合并姓名等）[52]   */

            listUserinfo = mUserinfoService.batchQueryUserinfoList(batchQueryUserinfoListReq);


            listUserinfo_1 = listUserinfo;
        }

        QueryOrgStaffListRespDto retData = new QueryOrgStaffListRespDto();
        //数据集融合  MoreListToOneSource
        if (listOriginalRoleMember_3 != null && !CollectionUtil.isEmpty(listOriginalRoleMember_3)) {
            for (OriginalRoleMember originalRoleMember : listOriginalRoleMember_3) {
                BeginMemberDto retElm = new BeginMemberDto();
                retElm.setOriginalRoleMemberId(originalRoleMember.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:39066_2
                retElm.setUserId(originalRoleMember.getUserId());//SimpleFieldAssign//sourceId:35256_2
                retData.getBeginMemberList().add(retElm);
                if (listUserinfo_1 != null) {
                    for (Userinfo userinfo : listUserinfo_1) {
                        if (userinfo.getUserId().equals(originalRoleMember.getUserId())) {
                            retElm.setUserFace(userinfo.getUserFace());//SimpleFieldAssign//sourceId:35253_2
                            retElm.setIdCardName(userinfo.getIdCardName());//SimpleFieldAssign//sourceId:35255_2
                            retElm.setNickName(userinfo.getNickName());//SimpleFieldAssign//sourceId:35258_2
                        }
                    }
                }

                if (listOriginalRoleMemberInfo_1 != null) {
                    for (OriginalRoleMemberInfo originalRoleMemberInfo : listOriginalRoleMemberInfo_1) {
                        if (originalRoleMemberInfo.getOriginalRoleMemberId().equals(originalRoleMember.getOriginalRoleMemberId())) {
                            retElm.setRoleMemberCode(originalRoleMemberInfo.getRoleMemberCode());//SimpleFieldAssign//sourceId:35257_2
                            retElm.setPositionIdName(originalRoleMemberInfo.getPositionIdName());//SimpleFieldAssign//sourceId:35259_2
                            retElm.setIsPtJob(originalRoleMemberInfo.getIsPtJob());//SimpleFieldAssign//sourceId:35260_2
                        }
                    }
                }

            }
        }//sourceId:63312_1


        return retData;
    }

    /**
     * D1-2修改身份人员资料[1154]
     * gen by moon at 10/1/2022, 11:59:20 PM
     */
    @Trace(operationName = "D1-2修改身份人员资料")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public UpdateBeginMembInfoRespDto updateBeginMembInfo(UpdateBeginMembInfoReqDto reqDto) {


        //virtualUsage D1判断注册完善员工操作可用(公共)  13309
        JudgeAddPerfectStaffUsableComRespDto judgeAddPerfectStaffUsableComRespDto = null;
        JudgeAddPerfectStaffUsableComReqDto judgeAddPerfectStaffUsableComReqDto = new JudgeAddPerfectStaffUsableComReqDto();
        judgeAddPerfectStaffUsableComReqDto.setRoleCode("ORG_ADMIN");//CUSTOM_CONVENTION//sourceId:213932_1_13309
        judgeAddPerfectStaffUsableComReqDto.setPrivacyCode("MGT_ORG_POWER");//CUSTOM_CONVENTION//sourceId:213933_1_13309
        if (reqDto != null) {
            judgeAddPerfectStaffUsableComReqDto.setRoleMemberCode(reqDto.getRoleMemberCode());//SimpleFieldAssign//sourceId:213912_1_13309
        }

        /*D1判断注册完善员工操作可用(公共)[4015]   */
        Assert.isNull(judgeAddPerfectStaffUsableComReqDto.getRoleCode(), "D1-2修改身份人员资料-D1判断注册完善员工操作可用(公共)-角色标识不能为空", false);
        Assert.isNull(judgeAddPerfectStaffUsableComReqDto.getPrivacyCode(), "D1-2修改身份人员资料-D1判断注册完善员工操作可用(公共)-权限标识不能为空", false);
        judgeAddPerfectStaffUsableComRespDto = judgeAddPerfectStaffUsableCom(judgeAddPerfectStaffUsableComReqDto);
        Assert.isTrue(judgeAddPerfectStaffUsableComRespDto == null || judgeAddPerfectStaffUsableComRespDto.getOutputNum() == null, "返回值不能为空", false);


//virtualUsage D2-3查询配置项匹配结果转答案(公共)  13240
        QueryItemMatchResultToAnswerDetailComRespDto queryItemMatchResultToAnswerDetailComRespDto = null;
        QueryItemMatchResultToAnswerDetailComReqDto queryItemMatchResultToAnswerDetailComReqDto = new QueryItemMatchResultToAnswerDetailComReqDto();
        queryItemMatchResultToAnswerDetailComReqDto.setConfItemCode("ORG_STRUCTURE_MODEL");//CUSTOM_CONVENTION//sourceId:212803_1_13240
        queryItemMatchResultToAnswerDetailComReqDto.setResultAspObjType("TENANT_SPACE");//sourceId:212804_1_13240
        queryItemMatchResultToAnswerDetailComReqDto.setResultAspObjId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:212805_1_13240
        queryItemMatchResultToAnswerDetailComReqDto.setIsInitialScheme("TRUE");//sourceId:308481_1_13240
        queryItemMatchResultToAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:308482_1_13240

        /*D2-3查询配置项匹配结果转答案(公共)[3094]   */
        Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto.getConfItemCode(), "D1-2修改身份人员资料-D2-3查询配置项匹配结果转答案(公共)-配置项标识不能为空", false);
        Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto.getResultAspObjType(), "D1-2修改身份人员资料-D2-3查询配置项匹配结果转答案(公共)-答案归属对象类型不能为空", false);
        Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto.getResultAspObjId(), "D1-2修改身份人员资料-D2-3查询配置项匹配结果转答案(公共)-答案归属对象ID不能为空", false);
        Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto.getIsInitialScheme(), "D1-2修改身份人员资料-D2-3查询配置项匹配结果转答案(公共)-是否初始方案答案不能为空", false);
        Assert.isNull(queryItemMatchResultToAnswerDetailComReqDto.getIsPlatData(), "D1-2修改身份人员资料-D2-3查询配置项匹配结果转答案(公共)-是否平台数据不能为空", false);
        queryItemMatchResultToAnswerDetailComRespDto = confSchemeService.queryItemMatchResultToAnswerDetailCom(queryItemMatchResultToAnswerDetailComReqDto).getData();
        Assert.isTrue(queryItemMatchResultToAnswerDetailComRespDto == null || queryItemMatchResultToAnswerDetailComRespDto.getOrgStructureModel() == null, "返回值不能为空", false);


//virtualUsage 1-2-10查询身份人员资料详情  14363
        OriginalRoleMemberInfo originalRoleMemberInfo = null;
        QueryBeginMembInfoDetailReq queryBeginMembInfoDetailReq = new QueryBeginMembInfoDetailReq();
        queryBeginMembInfoDetailReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:254594_1_14363
        if (reqDto != null) {
            queryBeginMembInfoDetailReq.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:254590_1_14363
        }

        /*1-2-10查询身份人员资料详情[116]   */
        Assert.isNull(queryBeginMembInfoDetailReq.getSpaceId(), "D1-2修改身份人员资料-1-2-10查询身份人员资料详情-创建于空间ID不能为空", false);
        originalRoleMemberInfo = mOriginalRoleMemberInfoService.queryBeginMembInfoDetail(queryBeginMembInfoDetailReq);


//virtualUsage 1-2-10修改身份人员资料  13242
        boolean bOOLEAN;
        if (originalRoleMemberInfo != null) {
            OriginalRoleMemberInfo originalRoleMemberInfo_2 = new OriginalRoleMemberInfo();
            if (originalRoleMemberInfo != null) {
                originalRoleMemberInfo_2.setOriginalStafInfoId(originalRoleMemberInfo.getOriginalStafInfoId());//SimpleFieldAssign//sourceId:24532_1_13242
            }
            if (reqDto != null) {
                originalRoleMemberInfo_2.setInductionTypeDictionaryId(reqDto.getInductionTypeDictionaryId());//SimpleFieldAssign//sourceId:24535_1_13242
                originalRoleMemberInfo_2.setInductionStateDictionaryId(reqDto.getInductionStateDictionaryId());//SimpleFieldAssign//sourceId:24536_1_13242
                originalRoleMemberInfo_2.setPositionIdName(reqDto.getPositionIdName());//SimpleFieldAssign//sourceId:24534_1_13242
                originalRoleMemberInfo_2.setRoleMemberCode(reqDto.getRoleMemberCode());//SimpleFieldAssign//sourceId:30796_1_13242
                originalRoleMemberInfo_2.setIsPtJob(reqDto.getIsPtJob());//SimpleFieldAssign//sourceId:37835_1_13242
                originalRoleMemberInfo_2.setRelaMemo(reqDto.getRelaMemo());//SimpleFieldAssign//sourceId:29987_1_13242
            }

            /*1-2-10修改身份人员资料[114]   */

            bOOLEAN = mOriginalRoleMemberInfoService.updateBeginMembInfo(originalRoleMemberInfo_2);


        }
        if ((reqDto != null && reqDto.getDirectorInductionRecordId() != null && queryItemMatchResultToAnswerDetailComRespDto != null && queryItemMatchResultToAnswerDetailComRespDto.getOrgStructureModel() != null && queryItemMatchResultToAnswerDetailComRespDto.getOrgStructureModel().equals("NO_ORG"))) {
            //if((D1-2修改身份人员资料.可选主管就职记录ID 值不等于空  and D2-3查询配置项匹配结果转答案(公共).空间组织架构模式 等于 无组织架构))  13241

            InductionRecord inductionRecord = null;
            QueryinductionRecordDetailReq queryinductionRecordDetailReq = new QueryinductionRecordDetailReq();
            queryinductionRecordDetailReq.setIsMainInduction("TRUE");//sourceId:154704_1_13243
            queryinductionRecordDetailReq.setOrganizationId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecHighestOrgID());//CURRENT_HIGH_ORGID//sourceId:212764_1_13243
            queryinductionRecordDetailReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:154705_1_13243
            if (reqDto != null) {
                queryinductionRecordDetailReq.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:154661_1_13243
            }

            /*1-3-13查询就职记录详情[165]   */
            Assert.isNull(queryinductionRecordDetailReq.getIsMainInduction(), "D1-2修改身份人员资料-1-3-13查询就职记录详情-是否主岗不能为空", false);
            Assert.isNull(queryinductionRecordDetailReq.getOrganizationId(), "D1-2修改身份人员资料-1-3-13查询就职记录详情-组织ID不能为空", false);
            Assert.isNull(queryinductionRecordDetailReq.getSpaceId(), "D1-2修改身份人员资料-1-3-13查询就职记录详情-创建于空间ID不能为空", false);
            inductionRecord = mInductionRecordService.queryinductionRecordDetail(queryinductionRecordDetailReq);


            boolean bOOLEAN_1;
            if (inductionRecord != null) {
                InductionRecord inductionRecord_2 = new InductionRecord();
                if (inductionRecord != null) {
                    inductionRecord_2.setInductionRecordId(inductionRecord.getInductionRecordId());//SimpleFieldAssign//sourceId:154699_1_13244
                }
                if (reqDto != null) {
                    inductionRecord_2.setDirectorInductionRecordId(reqDto.getDirectorInductionRecordId());//SimpleFieldAssign//sourceId:154700_1_13244
                    inductionRecord_2.setPositionIdName(reqDto.getPositionIdName());//SimpleFieldAssign//sourceId:154706_1_13244
                }

                /*1-3-13修改就职记录[163]   */
                Assert.isNull(inductionRecord_2.getInductionRecordId(), "D1-2修改身份人员资料-1-3-13修改就职记录-就职记录ID不能为空", false);
                bOOLEAN_1 = mInductionRecordService.updateInductionRecord(inductionRecord_2);


            }
//processBranchName:正常结束 ,processBranchId:13245

        }
        UpdateBeginMembInfoRespDto retData = new UpdateBeginMembInfoRespDto();


        return retData;
    }

    /**
     * D1-2查询身份人员列表[988]
     * gen by moon at 10/2/2022, 7:53:07 AM
     */
    @Trace(operationName = "D1-2查询身份人员列表")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryBeginMemberListRespDto queryBeginMemberList(QueryBeginMemberListReqDto reqDto) {


        List<OriginalRoleMember> listOriginalRoleMember_1 = new ArrayList<>();
//步骤0: 1-2-09查询身份人员列表 - queryBeginMemberList
        List<OriginalRoleMember> listOriginalRoleMember = new ArrayList<>();
        QueryBeginMemberListReq queryBeginMemberListReq = new QueryBeginMemberListReq();
        if (reqDto != null) {
            queryBeginMemberListReq.setUserId(reqDto.getUserId());//SimpleFieldAssign//sourceId:51296_1
            queryBeginMemberListReq.setRoleId(reqDto.getRoleId());//SimpleFieldAssign//sourceId:21068_1
            queryBeginMemberListReq.setRoleCode(reqDto.getRoleCode());//SimpleFieldAssign//sourceId:21080_1
            queryBeginMemberListReq.setFirstLetter(reqDto.getFirstLetter());//SimpleFieldAssign//sourceId:21069_1
            queryBeginMemberListReq.setSource(reqDto.getSource());//SimpleFieldAssign//sourceId:21070_1
            queryBeginMemberListReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:21217_1
            queryBeginMemberListReq.setIsArchive(reqDto.getIsArchive());//SimpleFieldAssign//sourceId:21081_1
            queryBeginMemberListReq.setOperateTime(reqDto.getOperateTime());//SimpleFieldAssign//sourceId:21803_1
            queryBeginMemberListReq.setCreateTime(reqDto.getCreateTime());//SimpleFieldAssign//sourceId:21156_1
            queryBeginMemberListReq.setIsInvalid(reqDto.getIsInvalid());//SimpleFieldAssign//sourceId:21086_1
            queryBeginMemberListReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:21074_1
        }

        /*1-2-09查询身份人员列表[80]   */

        listOriginalRoleMember = mOriginalRoleMemberService.queryBeginMemberList(queryBeginMemberListReq);


        listOriginalRoleMember_1 = listOriginalRoleMember;

        QueryBeginMemberListRespDto retData = new QueryBeginMemberListRespDto();
        retData.setBeginMemberList(listOriginalRoleMember_1.stream().map(item -> BeanUtil.toBean(item, BeginMemberDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:22070_1


        return retData;
    }

    /**
     * D1-2查询身份人员列表（边界）[1357]
     * gen by moon at 8/10/2022, 3:15:41 AM
     */
    @Trace(operationName = "D1-2查询身份人员列表（边界）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryBeginMemberListBorderRespDto queryBeginMemberListBorder(QueryBeginMemberListBorderReqDto reqDto) {


        List<OriginalRoleMember> listOriginalRoleMember_1 = new ArrayList<>();
        List<Userinfo> listUserinfo_1 = new ArrayList<>();
        List<OriginalRoleMemberInfo> listOriginalRoleMemberInfo_1 = new ArrayList<>();
        List<Userinfo> listUserinfo_3 = new ArrayList<>();
        List<OriginalRoleMember> listOriginalRoleMember_3 = new ArrayList<>();
        if ((reqDto != null && reqDto.getIdCardName() == null)) {
            //if(D1-2查询身份人员列表（边界）.真实姓名 等于空 )  281

            List<OriginalRoleMember> listOriginalRoleMember = new ArrayList<>();
            QueryBeginMemberListReq queryBeginMemberListReq = new QueryBeginMemberListReq();
            queryBeginMemberListReq.setIsTransaction("FALSE");//sourceId:51097_1_282
            if (reqDto != null) {
                queryBeginMemberListReq.setRoleCode(reqDto.getRoleCode());//sourceId:32340_1_282
                queryBeginMemberListReq.setSource(reqDto.getSource());//sourceId:32341_1_282
                queryBeginMemberListReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//sourceId:32342_1_282
                queryBeginMemberListReq.setIsArchive(reqDto.getIsArchive());//sourceId:39883_1_282
                queryBeginMemberListReq.setIsInvalid(reqDto.getIsInvalid());//sourceId:32343_1_282
                queryBeginMemberListReq.setSpaceId(reqDto.getSpaceId());//sourceId:32344_1_282
            }

            /*1-2-09查询身份人员列表（非搜索）[80]   */

            listOriginalRoleMember = mOriginalRoleMemberService.queryBeginMemberList(queryBeginMemberListReq);

            listOriginalRoleMember_1 = listOriginalRoleMember;
            List<Userinfo> listUserinfo = new ArrayList<>();
            if (listOriginalRoleMember != null && listOriginalRoleMember.size() > 0) {
                BatchQueryUserinfoListReq batchQueryUserinfoListReq = new BatchQueryUserinfoListReq();
                batchQueryUserinfoListReq.setUserList(listOriginalRoleMember.stream().map(item -> item.getUserId())
                        .collect(Collectors.toList()));//sourceId:32335_1_283

                /*1-2-02批量查询个人资料列表[52]   */

                listUserinfo = mUserinfoService.batchQueryUserinfoList(batchQueryUserinfoListReq);

                listUserinfo_1 = listUserinfo;
            }
            List<OriginalRoleMemberInfo> listOriginalRoleMemberInfo = new ArrayList<>();
            if (listOriginalRoleMember != null && listOriginalRoleMember.size() > 0) {
                BatchQueryBeginMembInfoListReq batchQueryBeginMembInfoListReq = new BatchQueryBeginMembInfoListReq();
                batchQueryBeginMembInfoListReq.setBeginMembInfoList(listOriginalRoleMember.stream().map(item -> item.getOriginalRoleMemberId())
                        .collect(Collectors.toList()));//sourceId:32338_1_284

                /*1-2-10批量查询身份人员资料列表[1014]   */

                listOriginalRoleMemberInfo = mOriginalRoleMemberInfoService.batchQueryBeginMembInfoList(batchQueryBeginMembInfoListReq);

                listOriginalRoleMemberInfo_1 = listOriginalRoleMemberInfo;
            }
//processBranchName:正常结束 ,processBranchId:285

        } else {
            //else  286

            List<Userinfo> listUserinfo_2 = new ArrayList<>();
            QueryUserInfoListReq queryUserInfoListReq = new QueryUserInfoListReq();
            if (reqDto != null) {
                queryUserInfoListReq.setIdCardName(reqDto.getIdCardName());//sourceId:32339_1_287
            }

            /*1-2-02查询个人资料列表（真实姓名搜索）[1178]   */

            listUserinfo_2 = mUserinfoService.queryUserInfoList(queryUserInfoListReq);

            listUserinfo_3 = listUserinfo_2;
            List<OriginalRoleMember> listOriginalRoleMember_2 = new ArrayList<>();
            if (listUserinfo_2 != null && listUserinfo_2.size() > 0) {
                BatchQueryStaffBeginMemberListReq batchQueryStaffBeginMemberListReq = new BatchQueryStaffBeginMemberListReq();
                batchQueryStaffBeginMemberListReq.setStaffBeginMemberList(listUserinfo_2.stream().map(item -> item.getUserId())
                        .collect(Collectors.toList()));//sourceId:32325_1_288
                batchQueryStaffBeginMemberListReq.setIsTransaction("FALSE");//sourceId:51096_1_288
                if (reqDto != null) {
                    batchQueryStaffBeginMemberListReq.setSource(reqDto.getSource());//sourceId:32328_1_288
                    batchQueryStaffBeginMemberListReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//sourceId:49691_1_288
                    batchQueryStaffBeginMemberListReq.setIsArchive(reqDto.getIsArchive());//sourceId:32327_1_288
                    batchQueryStaffBeginMemberListReq.setIsInvalid(reqDto.getIsInvalid());//sourceId:32329_1_288
                    batchQueryStaffBeginMemberListReq.setSpaceId(reqDto.getSpaceId());//sourceId:32330_1_288
                }

                /*1-2-09批量查询员工身份人员列表[1259]   */

                listOriginalRoleMember_2 = mOriginalRoleMemberService.batchQueryStaffBeginMemberList(batchQueryStaffBeginMemberListReq);

                listOriginalRoleMember_3 = listOriginalRoleMember_2;
            }
            List<Userinfo> listUserinfo_4 = new ArrayList<>();
            if (listOriginalRoleMember_2 != null && listOriginalRoleMember_2.size() > 0) {
                BatchQueryUserinfoListReq batchQueryUserinfoListReq_1 = new BatchQueryUserinfoListReq();
                batchQueryUserinfoListReq_1.setUserList(listOriginalRoleMember_2.stream().map(item -> item.getUserId())
                        .collect(Collectors.toList()));//sourceId:32335_1_289

                /*1-2-02批量查询个人资料列表[52]   */

                listUserinfo_4 = mUserinfoService.batchQueryUserinfoList(batchQueryUserinfoListReq_1);

                listUserinfo_1 = listUserinfo_4;
            }
            List<OriginalRoleMemberInfo> listOriginalRoleMemberInfo_2 = new ArrayList<>();
            if (listOriginalRoleMember_2 != null && listOriginalRoleMember_2.size() > 0) {
                BatchQueryBeginMembInfoListReq batchQueryBeginMembInfoListReq_1 = new BatchQueryBeginMembInfoListReq();
                batchQueryBeginMembInfoListReq_1.setBeginMembInfoList(listOriginalRoleMember_2.stream().map(item -> item.getOriginalRoleMemberId())
                        .collect(Collectors.toList()));//sourceId:32338_1_290

                /*1-2-10批量查询身份人员资料列表[1014]   */

                listOriginalRoleMemberInfo_2 = mOriginalRoleMemberInfoService.batchQueryBeginMembInfoList(batchQueryBeginMembInfoListReq_1);

                listOriginalRoleMemberInfo_1 = listOriginalRoleMemberInfo_2;
            }
//processBranchName:正常结束 ,processBranchId:291

        }
        QueryBeginMemberListBorderRespDto retData = new QueryBeginMemberListBorderRespDto();
        //sourceId:32350_1


        return retData;
    }

    /**
     * D1-3取消异动员工身份人员[1694]
     * gen by moon at 10/2/2022, 12:20:31 AM
     */
    @Trace(operationName = "D1-3取消异动员工身份人员")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public CancelTransactionStaffBeginMemberRespDto cancelTransactionStaffBeginMember(CancelTransactionStaffBeginMemberReqDto reqDto) {


        //步骤0: 1-3-13查询就职记录列表 - queryInductionRecordList
        List<InductionRecord> listInductionRecord = new ArrayList<>();
        QueryInductionRecordListReq queryInductionRecordListReq = new QueryInductionRecordListReq();
        queryInductionRecordListReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:50500_1
        queryInductionRecordListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:50573_1
        if (reqDto != null) {
            queryInductionRecordListReq.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:50496_1
        }

        /*1-3-13查询就职记录列表[166]   */
        Assert.isNull(queryInductionRecordListReq.getOriginalRoleMemberId(), "D1-3取消异动员工身份人员-1-3-13查询就职记录列表-身份人员ID不能为空", false);
        Assert.isNull(queryInductionRecordListReq.getSubjectLifeCycle(), "D1-3取消异动员工身份人员-1-3-13查询就职记录列表-主体生命周期不能为空", false);
        Assert.isNull(queryInductionRecordListReq.getSpaceId(), "D1-3取消异动员工身份人员-1-3-13查询就职记录列表-创建于空间ID不能为空", false);
        listInductionRecord = mInductionRecordService.queryInductionRecordList(queryInductionRecordListReq);


//步骤1: 1-3-13批量修改就职记录 - batchUpdateInductionRecord
        boolean bOOLEAN;
        if (listInductionRecord != null && listInductionRecord.size() > 0) {
            List<InductionRecord> listInductionRecord_2 = new ArrayList<>();
            listInductionRecord_2 = listInductionRecord.stream().map(item -> {
                InductionRecord elm = BeanUtil.toBean(item, InductionRecord.class);
                elm.setIsTransaction("FALSE");

                return elm;
            }).collect(Collectors.toList());//objList-to-objLists//sourceId:50501_1

            /*1-3-13批量修改就职记录（取消异动）[1647]   */

            bOOLEAN = mInductionRecordService.batchUpdateInductionRecord(listInductionRecord_2);


        }

//步骤2: 1-2-09修改身份人员 - updateBeginMember
        boolean bOOLEAN_1;
        OriginalRoleMember originalRoleMember = new OriginalRoleMember();
        originalRoleMember.setIsTransaction("FALSE");//sourceId:51074_1
        if (reqDto != null) {
            originalRoleMember.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:51064_1
        }

        /*1-2-09修改身份人员（取消异动）[78]   */
        Assert.isNull(originalRoleMember.getOriginalRoleMemberId(), "D1-3取消异动员工身份人员-1-2-09修改身份人员（取消异动）-身份人员ID不能为空", false);
        Assert.isNull(originalRoleMember.getIsTransaction(), "D1-3取消异动员工身份人员-1-2-09修改身份人员（取消异动）-是否异动不能为空", false);
        bOOLEAN_1 = mOriginalRoleMemberService.updateBeginMember(originalRoleMember);


        CancelTransactionStaffBeginMemberRespDto retData = new CancelTransactionStaffBeginMemberRespDto();


        return retData;
    }

    /**
     * D1-3设异动员工身份人员[1693]
     * gen by moon at 10/2/2022, 12:20:14 AM
     */
    @Trace(operationName = "D1-3设异动员工身份人员")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public InTransactionStaffBeginMemberRespDto inTransactionStaffBeginMember(InTransactionStaffBeginMemberReqDto reqDto) {


        //步骤0: 1-3-13查询就职记录列表 - queryInductionRecordList
        List<InductionRecord> listInductionRecord = new ArrayList<>();
        QueryInductionRecordListReq queryInductionRecordListReq = new QueryInductionRecordListReq();
        queryInductionRecordListReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:50508_1
        queryInductionRecordListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:50572_1
        if (reqDto != null) {
            queryInductionRecordListReq.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:50451_1
        }

        /*1-3-13查询就职记录列表[166]   */
        Assert.isNull(queryInductionRecordListReq.getOriginalRoleMemberId(), "D1-3设异动员工身份人员-1-3-13查询就职记录列表-身份人员ID不能为空", false);
        Assert.isNull(queryInductionRecordListReq.getSubjectLifeCycle(), "D1-3设异动员工身份人员-1-3-13查询就职记录列表-主体生命周期不能为空", false);
        Assert.isNull(queryInductionRecordListReq.getSpaceId(), "D1-3设异动员工身份人员-1-3-13查询就职记录列表-创建于空间ID不能为空", false);
        listInductionRecord = mInductionRecordService.queryInductionRecordList(queryInductionRecordListReq);


//步骤1: 1-3-13批量修改就职记录 - batchUpdateInductionRecord
        boolean bOOLEAN;
        if (listInductionRecord != null && listInductionRecord.size() > 0) {
            List<InductionRecord> listInductionRecord_2 = new ArrayList<>();
            listInductionRecord_2 = listInductionRecord.stream().map(item -> {
                InductionRecord elm = BeanUtil.toBean(item, InductionRecord.class);
                elm.setIsTransaction("TRUE");

                return elm;
            }).collect(Collectors.toList());//objList-to-objLists//sourceId:50455_1

            /*1-3-13批量修改就职记录（设为异动）[1647]   */

            bOOLEAN = mInductionRecordService.batchUpdateInductionRecord(listInductionRecord_2);


        }

//步骤2: 1-2-09修改身份人员 - updateBeginMember
        boolean bOOLEAN_1;
        OriginalRoleMember originalRoleMember = new OriginalRoleMember();
        originalRoleMember.setIsTransaction("TRUE");//sourceId:51085_1
        if (reqDto != null) {
            originalRoleMember.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:51075_1
        }

        /*1-2-09修改身份人员（设为异动）[78]   */
        Assert.isNull(originalRoleMember.getOriginalRoleMemberId(), "D1-3设异动员工身份人员-1-2-09修改身份人员（设为异动）-身份人员ID不能为空", false);
        Assert.isNull(originalRoleMember.getIsTransaction(), "D1-3设异动员工身份人员-1-2-09修改身份人员（设为异动）-是否异动不能为空", false);
        bOOLEAN_1 = mOriginalRoleMemberService.updateBeginMember(originalRoleMember);


        InTransactionStaffBeginMemberRespDto retData = new InTransactionStaffBeginMemberRespDto();


        return retData;
    }

    /**
     * D1-3存档员工身份人员[1683]
     * gen by moon at 10/2/2022, 12:19:20 AM
     */
    @Trace(operationName = "D1-3存档员工身份人员")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ArchiveBeginMemberRespDto archiveBeginMember(ArchiveBeginMemberReqDto reqDto) {


        //步骤0: 1-3-13查询就职记录列表 - queryInductionRecordList
        List<InductionRecord> listInductionRecord = new ArrayList<>();
        QueryInductionRecordListReq queryInductionRecordListReq = new QueryInductionRecordListReq();
        queryInductionRecordListReq.setSubjectLifeCycle("EDITING");//sourceId:50105_1
        queryInductionRecordListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:50346_1
        if (reqDto != null) {
            queryInductionRecordListReq.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:50104_1
        }

        /*1-3-13查询就职记录列表（正在编辑）[166]   */
        Assert.isNull(queryInductionRecordListReq.getOriginalRoleMemberId(), "D1-3存档员工身份人员-1-3-13查询就职记录列表（正在编辑）-身份人员ID不能为空", false);
        Assert.isNull(queryInductionRecordListReq.getSubjectLifeCycle(), "D1-3存档员工身份人员-1-3-13查询就职记录列表（正在编辑）-主体生命周期不能为空", false);
        Assert.isNull(queryInductionRecordListReq.getSpaceId(), "D1-3存档员工身份人员-1-3-13查询就职记录列表（正在编辑）-创建于空间ID不能为空", false);
        listInductionRecord = mInductionRecordService.queryInductionRecordList(queryInductionRecordListReq);


//步骤1: 1-3-13批量删除就职记录 - batchDeleteInductionRecord
        boolean bOOLEAN;
        if (listInductionRecord != null && listInductionRecord.size() > 0) {
            List<String> listString = new ArrayList<>();
            listString = listInductionRecord.stream().map(item -> item.getInductionRecordId())
                    .collect(Collectors.toList());/*list-to-strings*///sourceId:50276_1

            /*1-3-13批量删除就职记录[1685]   */

            bOOLEAN = mInductionRecordService.batchDeleteInductionRecord(listString);


        }

//步骤2: 1-3-13查询就职记录列表 - queryInductionRecordList
        List<InductionRecord> listInductionRecord_2 = new ArrayList<>();
        QueryInductionRecordListReq queryInductionRecordListReq_1 = new QueryInductionRecordListReq();
        queryInductionRecordListReq_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:50279_1
        queryInductionRecordListReq_1.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:50347_1
        if (reqDto != null) {
            queryInductionRecordListReq_1.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:50278_1
        }

        /*1-3-13查询就职记录列表（当前有效）[166]   */
        Assert.isNull(queryInductionRecordListReq_1.getOriginalRoleMemberId(), "D1-3存档员工身份人员-1-3-13查询就职记录列表（当前有效）-身份人员ID不能为空", false);
        Assert.isNull(queryInductionRecordListReq_1.getSubjectLifeCycle(), "D1-3存档员工身份人员-1-3-13查询就职记录列表（当前有效）-主体生命周期不能为空", false);
        Assert.isNull(queryInductionRecordListReq_1.getSpaceId(), "D1-3存档员工身份人员-1-3-13查询就职记录列表（当前有效）-创建于空间ID不能为空", false);
        listInductionRecord_2 = mInductionRecordService.queryInductionRecordList(queryInductionRecordListReq_1);


//步骤3: 1-3-13批量修改就职记录 - batchUpdateInductionRecord
        boolean bOOLEAN_1;
        if (listInductionRecord_2 != null && listInductionRecord_2.size() > 0) {
            List<InductionRecord> listInductionRecord_4 = new ArrayList<>();
            listInductionRecord_4 = listInductionRecord_2.stream().map(item -> {
                InductionRecord elm = BeanUtil.toBean(item, InductionRecord.class);
                elm.setBatchEndTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME
                elm.setInductionEndTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME
                elm.setSubjectLifeCycle("ARCHIVING");
                elm.setIsArchive("TRUE");
                elm.setArchivngType("ARCHIVED");

                return elm;
            }).collect(Collectors.toList());//objList-to-objLists//sourceId:50179_1

            /*1-3-13批量修改就职记录[1647]   */

            bOOLEAN_1 = mInductionRecordService.batchUpdateInductionRecord(listInductionRecord_4);


        }

//步骤4: 1-2-13查询角色人员列表 - queryRoleRelList
        List<RoleMember> listRoleMember = new ArrayList<>();
        QueryRoleRelListReq queryRoleRelListReq = new QueryRoleRelListReq();
        queryRoleRelListReq.setSubjectLifeCycle("EDITING");//sourceId:50295_1
        queryRoleRelListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:50348_1
        if (reqDto != null) {
            queryRoleRelListReq.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:50293_1
        }

        /*1-2-13查询角色人员列表（正在编辑）[334]   */
        Assert.isNull(queryRoleRelListReq.getOriginalRoleMemberId(), "D1-3存档员工身份人员-1-2-13查询角色人员列表（正在编辑）-身份人员ID不能为空", false);
        Assert.isNull(queryRoleRelListReq.getSubjectLifeCycle(), "D1-3存档员工身份人员-1-2-13查询角色人员列表（正在编辑）-主体生命周期不能为空", false);
        Assert.isNull(queryRoleRelListReq.getSpaceId(), "D1-3存档员工身份人员-1-2-13查询角色人员列表（正在编辑）-创建于空间ID不能为空", false);
        listRoleMember = mRoleMemberService.queryRoleRelList(queryRoleRelListReq);


//步骤5: 1-2-13批量删除角色人员 - batchDeleteRoleRel
        boolean bOOLEAN_2;
        if (listRoleMember != null && listRoleMember.size() > 0) {
            List<String> listString_1 = new ArrayList<>();
            listString_1 = listRoleMember.stream().map(item -> item.getRoleMemberId())
                    .collect(Collectors.toList());/*list-to-strings*///sourceId:50202_1

            /*1-2-13批量删除角色人员[1559]   */

            bOOLEAN_2 = mRoleMemberService.batchDeleteRoleRel(listString_1);


        }

//步骤6: 1-2-13查询角色人员列表 - queryRoleRelList
        List<RoleMember> listRoleMember_2 = new ArrayList<>();
        QueryRoleRelListReq queryRoleRelListReq_1 = new QueryRoleRelListReq();
        queryRoleRelListReq_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:50300_1
        queryRoleRelListReq_1.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:50349_1
        if (reqDto != null) {
            queryRoleRelListReq_1.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:50298_1
        }

        /*1-2-13查询角色人员列表（当前有效）[334]   */
        Assert.isNull(queryRoleRelListReq_1.getOriginalRoleMemberId(), "D1-3存档员工身份人员-1-2-13查询角色人员列表（当前有效）-身份人员ID不能为空", false);
        Assert.isNull(queryRoleRelListReq_1.getSubjectLifeCycle(), "D1-3存档员工身份人员-1-2-13查询角色人员列表（当前有效）-主体生命周期不能为空", false);
        Assert.isNull(queryRoleRelListReq_1.getSpaceId(), "D1-3存档员工身份人员-1-2-13查询角色人员列表（当前有效）-创建于空间ID不能为空", false);
        listRoleMember_2 = mRoleMemberService.queryRoleRelList(queryRoleRelListReq_1);


//步骤7: 1-2-13批量修改角色人员 - batchUpdateRoleRel
        boolean bOOLEAN_3;
        if (listRoleMember_2 != null && listRoleMember_2.size() > 0) {
            List<RoleMember> listRoleMember_4 = new ArrayList<>();
            listRoleMember_4 = listRoleMember_2.stream().map(item -> {
                RoleMember elm = BeanUtil.toBean(item, RoleMember.class);
                elm.setRelationshipValid("TRUE");
                elm.setSubjectLifeCycle("ARCHIVING");
                elm.setIsArchive("TRUE");

                return elm;
            }).collect(Collectors.toList());//objList-to-objLists//sourceId:50225_1

            /*1-2-13批量修改角色人员（存档）[1560]   */

            bOOLEAN_3 = mRoleMemberService.batchUpdateRoleRel(listRoleMember_4);


        }

//步骤8: 1-2-09修改身份人员 - updateBeginMember
        boolean bOOLEAN_4;
        OriginalRoleMember originalRoleMember = new OriginalRoleMember();
        originalRoleMember.setSubjectLifeCycle("ARCHIVING");//sourceId:49849_1
        originalRoleMember.setIsArchive("TRUE");//sourceId:49850_1
        originalRoleMember.setInvalidType("OTHER");//sourceId:49857_1
        originalRoleMember.setIsInvalid("TRUE");//sourceId:49858_1
        originalRoleMember.setInvalidReason("因为注销导致失效");//CUSTOM_CONVENTION//sourceId:49859_1
        originalRoleMember.setInvalidTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:49860_1
        if (reqDto != null) {
            originalRoleMember.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:49847_1
        }

        /*1-2-09修改身份人员（存档）[78]   */
        Assert.isNull(originalRoleMember.getOriginalRoleMemberId(), "D1-3存档员工身份人员-1-2-09修改身份人员（存档）-身份人员ID不能为空", false);
        Assert.isNull(originalRoleMember.getSubjectLifeCycle(), "D1-3存档员工身份人员-1-2-09修改身份人员（存档）-主体生命周期不能为空", false);
        Assert.isNull(originalRoleMember.getIsArchive(), "D1-3存档员工身份人员-1-2-09修改身份人员（存档）-是否存档不能为空", false);
        Assert.isNull(originalRoleMember.getInvalidType(), "D1-3存档员工身份人员-1-2-09修改身份人员（存档）-失效类型不能为空", false);
        Assert.isNull(originalRoleMember.getIsInvalid(), "D1-3存档员工身份人员-1-2-09修改身份人员（存档）-是否失效不能为空", false);
        Assert.isNull(originalRoleMember.getInvalidReason(), "D1-3存档员工身份人员-1-2-09修改身份人员（存档）-失效原因不能为空", false);
        Assert.isNull(originalRoleMember.getInvalidTime(), "D1-3存档员工身份人员-1-2-09修改身份人员（存档）-失效时间不能为空", false);
        bOOLEAN_4 = mOriginalRoleMemberService.updateBeginMember(originalRoleMember);


        ArchiveBeginMemberRespDto retData = new ArchiveBeginMemberRespDto();


        return retData;
    }

    /**
     * D1-2查询员工身份人员详情[392]
     * gen by moon at 10/16/2022, 4:39:41 AM
     */
    @Trace(operationName = "D1-2查询员工身份人员详情")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryStaffBeginMemberDetailRespDto queryStaffBeginMemberDetail(QueryStaffBeginMemberDetailReqDto reqDto) {


        OriginalRoleMember originalRoleMember_1 = null;
        InductionRecord inductionRecord_1 = null;
        Userinfo userinfo_1 = null;
        Users users_1 = null;
        Userinfo userinfo_3 = null;
        OriginalRoleMemberInfo originalRoleMemberInfo_1 = null;
//步骤0: 1-2-09查询身份人员详情 - queryBeginMemberDetail
        OriginalRoleMember originalRoleMember = null;
        QueryBeginMemberDetailReq queryBeginMemberDetailReq = new QueryBeginMemberDetailReq();
        if (reqDto != null) {
            queryBeginMemberDetailReq.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:7524_1
        }

        /*1-2-09查询身份人员详情[174]   */
        Assert.isNull(queryBeginMemberDetailReq.getOriginalRoleMemberId(), "D1-2查询员工身份人员详情-1-2-09查询身份人员详情-身份人员ID不能为空", false);
        originalRoleMember = mOriginalRoleMemberService.queryBeginMemberDetail(queryBeginMemberDetailReq);


        originalRoleMember_1 = originalRoleMember;

//步骤1: 1-3-13查询就职记录详情 - queryinductionRecordDetail
        InductionRecord inductionRecord = null;
        QueryinductionRecordDetailReq queryinductionRecordDetailReq = new QueryinductionRecordDetailReq();
        if (reqDto != null) {
            queryinductionRecordDetailReq.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:154860_1
        }

        /*查询就职记录详情-查主管就职记录[165]   */
        Assert.isNull(queryinductionRecordDetailReq.getOriginalRoleMemberId(), "D1-2查询员工身份人员详情-查询就职记录详情-查主管就职记录-身份人员ID不能为空", false);
        inductionRecord = mInductionRecordService.queryinductionRecordDetail(queryinductionRecordDetailReq);


        inductionRecord_1 = inductionRecord;

//步骤2: 1-3-13查询就职记录详情 - queryinductionRecordDetail
        InductionRecord inductionRecord_2 = null;
        if (inductionRecord != null && inductionRecord != null && inductionRecord.getDirectorInductionRecordId() != null) {
            QueryinductionRecordDetailReq queryinductionRecordDetailReq_1 = new QueryinductionRecordDetailReq();
            if (inductionRecord != null) {
                queryinductionRecordDetailReq_1.setInductionRecordId(inductionRecord.getDirectorInductionRecordId());//SimpleFieldAssign//sourceId:154987_1
            }

            /*查询就职记录详情-查主管就职记录的个人帐号[165]   */

            inductionRecord_2 = mInductionRecordService.queryinductionRecordDetail(queryinductionRecordDetailReq_1);


        }

//步骤3: 1-2-02查询个人资料详情 - queryUserinfoDetail
        Userinfo userinfo = null;
        if (inductionRecord_2 != null && inductionRecord_2 != null && inductionRecord_2.getUserId() != null) {
            QueryUserinfoDetailReq queryUserinfoDetailReq = new QueryUserinfoDetailReq();
            if (inductionRecord_2 != null) {
                queryUserinfoDetailReq.setUserId(inductionRecord_2.getUserId());//SimpleFieldAssign//sourceId:155143_1
            }

            /*查询个人资料详情-主管[155]   */

            userinfo = mUserinfoService.queryUserinfoDetail(queryUserinfoDetailReq);


            userinfo_1 = userinfo;
        }

//步骤4: 1-2-01查询个人账号详情 - queryUserDetail
        Users users = null;
        if (originalRoleMember != null) {
            QueryUserDetailReq queryUserDetailReq = new QueryUserDetailReq();
            if (originalRoleMember != null) {
                queryUserDetailReq.setUserId(originalRoleMember.getUserId());//SimpleFieldAssign//sourceId:24197_1
            }

            /*1-2-01查询个人账号详情[286]   */
            Assert.isNull(queryUserDetailReq.getUserId(), "D1-2查询员工身份人员详情-1-2-01查询个人账号详情-个人账号不能为空", false);
            users = mUsersService.queryUserDetail(queryUserDetailReq);


            users_1 = users;
        }

//步骤5: 1-2-02查询个人资料详情 - queryUserinfoDetail
        Userinfo userinfo_2 = null;
        if (originalRoleMember != null) {
            QueryUserinfoDetailReq queryUserinfoDetailReq_1 = new QueryUserinfoDetailReq();
            if (originalRoleMember != null) {
                queryUserinfoDetailReq_1.setUserId(originalRoleMember.getUserId());//SimpleFieldAssign//sourceId:24194_1
            }

            /*1-2-02查询个人资料详情[155]   */
            Assert.isNull(queryUserinfoDetailReq_1.getUserId(), "D1-2查询员工身份人员详情-1-2-02查询个人资料详情-账号不能为空", false);
            userinfo_2 = mUserinfoService.queryUserinfoDetail(queryUserinfoDetailReq_1);


            userinfo_3 = userinfo_2;
        }

//步骤6: 1-2-10查询身份人员资料详情 - queryBeginMembInfoDetail
        OriginalRoleMemberInfo originalRoleMemberInfo = null;
        if (originalRoleMember != null) {
            QueryBeginMembInfoDetailReq queryBeginMembInfoDetailReq = new QueryBeginMembInfoDetailReq();
            if (originalRoleMember != null) {
                queryBeginMembInfoDetailReq.setOriginalRoleMemberId(originalRoleMember.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:24166_1
            }

            /*1-2-10查询身份人员资料详情[116]   */
            Assert.isNull(queryBeginMembInfoDetailReq.getOriginalRoleMemberId(), "D1-2查询员工身份人员详情-1-2-10查询身份人员资料详情-身份人员ID不能为空", false);
            originalRoleMemberInfo = mOriginalRoleMemberInfoService.queryBeginMembInfoDetail(queryBeginMembInfoDetailReq);


            originalRoleMemberInfo_1 = originalRoleMemberInfo;
        }

        QueryStaffBeginMemberDetailRespDto retData = new QueryStaffBeginMemberDetailRespDto();
        if (originalRoleMemberInfo_1 != null) {
            retData.setOriginalStafInfoId(originalRoleMemberInfo_1.getOriginalStafInfoId());//SimpleFieldAssign//sourceId:141623_1
            retData.setRelaMemo(originalRoleMemberInfo_1.getRelaMemo());//SimpleFieldAssign//sourceId:24241_1
            retData.setRoleMemberCode(originalRoleMemberInfo_1.getRoleMemberCode());//SimpleFieldAssign//sourceId:24237_1
            retData.setPositionIdName(originalRoleMemberInfo_1.getPositionIdName());//SimpleFieldAssign//sourceId:24239_1
            retData.setInductionTypeDictionaryId(originalRoleMemberInfo_1.getInductionTypeDictionaryId());//SimpleFieldAssign//sourceId:24243_1
            retData.setInductionStateDictionaryId(originalRoleMemberInfo_1.getInductionStateDictionaryId());//SimpleFieldAssign//sourceId:24245_1
            retData.setIsPtJob(originalRoleMemberInfo_1.getIsPtJob());//SimpleFieldAssign//sourceId:38311_1
        }
        if (originalRoleMember_1 != null) {
            retData.setOriginalRoleMemberId(originalRoleMember_1.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:24143_1
            retData.setUserId(originalRoleMember_1.getUserId());//SimpleFieldAssign//sourceId:21398_1
            retData.setMemberId(originalRoleMember_1.getMemberId());//SimpleFieldAssign//sourceId:24144_1
            retData.setRoleId(originalRoleMember_1.getRoleId());//SimpleFieldAssign//sourceId:24145_1
            retData.setRoleCode(originalRoleMember_1.getRoleCode());//SimpleFieldAssign//sourceId:24146_1
            retData.setFirstLetter(originalRoleMember_1.getFirstLetter());//SimpleFieldAssign//sourceId:24147_1
            retData.setSource(originalRoleMember_1.getSource());//SimpleFieldAssign//sourceId:24148_1
            retData.setIsTransaction(originalRoleMember_1.getIsTransaction());//SimpleFieldAssign//sourceId:50515_1
            retData.setIsInvalid(originalRoleMember_1.getIsInvalid());//SimpleFieldAssign//sourceId:21389_1
            retData.setInvalidType(originalRoleMember_1.getInvalidType());//SimpleFieldAssign//sourceId:21330_1
            retData.setInvalidReason(originalRoleMember_1.getInvalidReason());//SimpleFieldAssign//sourceId:21328_1
            retData.setInvalidTime(originalRoleMember_1.getInvalidTime());//SimpleFieldAssign//sourceId:21329_1
            retData.setIsArchive(originalRoleMember_1.getIsArchive());//SimpleFieldAssign//sourceId:21388_1
            retData.setSubjectLifeCycle(originalRoleMember_1.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:24149_1
            retData.setOperationInductionId(originalRoleMember_1.getOperationInductionId());//SimpleFieldAssign//sourceId:24150_1
            retData.setOperateTime(originalRoleMember_1.getOperateTime());//SimpleFieldAssign//sourceId:24154_1
            retData.setSpaceId(originalRoleMember_1.getSpaceId());//SimpleFieldAssign//sourceId:24158_1
            retData.setAppId(originalRoleMember_1.getAppId());//SimpleFieldAssign//sourceId:24159_1
        }
        if (users_1 != null) {
            retData.setUserName(users_1.getUserName());//SimpleFieldAssign//sourceId:24226_1
            retData.setEmail(users_1.getEmail());//SimpleFieldAssign//sourceId:24227_1
            retData.setPassByEmail(users_1.getPassByEmail());//SimpleFieldAssign//sourceId:24228_1
            retData.setPhone(users_1.getPhone());//SimpleFieldAssign//sourceId:24229_1
            retData.setPassByPhone(users_1.getPassByPhone());//SimpleFieldAssign//sourceId:24230_1
            retData.setIsUserInfoDone(users_1.getIsUserInfoDone());//SimpleFieldAssign//sourceId:24231_1
            retData.setRegTime(users_1.getRegTime());//SimpleFieldAssign//sourceId:24232_1
            retData.setLastLoginTime(users_1.getLastLoginTime());//SimpleFieldAssign//sourceId:24233_1
            retData.setLastLoginIp(users_1.getLastLoginIp());//SimpleFieldAssign//sourceId:24234_1
            retData.setSourceCode(users_1.getSourceCode());//SimpleFieldAssign//sourceId:24235_1
            retData.setInviteUserId(users_1.getInviteUserId());//SimpleFieldAssign//sourceId:24236_1
        }
        if (userinfo_3 != null) {
            retData.setIdCardName(userinfo_3.getIdCardName());//SimpleFieldAssign//sourceId:24238_1
            retData.setNickName(userinfo_3.getNickName());//SimpleFieldAssign//sourceId:24240_1
            retData.setUserFace(userinfo_3.getUserFace());//SimpleFieldAssign//sourceId:24242_1
            retData.setUserIntro(userinfo_3.getUserIntro());//SimpleFieldAssign//sourceId:24244_1
            retData.setSex(userinfo_3.getSex());//SimpleFieldAssign//sourceId:24246_1
            retData.setBirthday(userinfo_3.getBirthday());//SimpleFieldAssign//sourceId:24247_1
            retData.setCity(userinfo_3.getCity());//SimpleFieldAssign//sourceId:24248_1
        }
        if (userinfo_1 != null) {
            retData.setManagerIdcardName(userinfo_1.getIdCardName());//SimpleFieldAssign//sourceId:155158_1
            retData.setManagerNickName(userinfo_1.getNickName());//SimpleFieldAssign//sourceId:155159_1
            retData.setManagerUserFace(userinfo_1.getUserFace());//SimpleFieldAssign//sourceId:155160_1
        }
        if (inductionRecord_1 != null) {
            retData.setDirectorInductionRecordId(inductionRecord_1.getDirectorInductionRecordId());//SimpleFieldAssign//sourceId:155161_1
        }


        return retData;
    }

    /**
     * D1-2查询部门员工列表（边界）[1604]
     */
    @Trace(operationName = "D1-2查询部门员工列表（边界）")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryDeptDirectStaffListBorderRespDto queryDeptDirectStaffListBorder(QueryDeptDirectStaffListBorderReqDto reqDto) {


        //步骤0: 1-3-13查询就职记录列表 - queryInductionRecordList
        List<InductionRecord> listInductionRecord = null;
        QueryInductionRecordListReq queryInductionRecordListReq = new QueryInductionRecordListReq();
        queryInductionRecordListReq.setInductionUnitTypeCode("DEPT");//sourceId:46450_1
        queryInductionRecordListReq.setIsTransaction("FALSE");//sourceId:51027_1
        queryInductionRecordListReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:46452_1
        if (reqDto != null) {
            queryInductionRecordListReq.setEntityId(reqDto.getEntityId());//sourceId:46451_1
        }

        /*1-3-13查询就职记录列表[166]   */
        listInductionRecord = mInductionRecordService.queryInductionRecordList(queryInductionRecordListReq);


//步骤1: 1-2-09批量查询身份人员列表	 - batchQueryBeginMemberList
        List<OriginalRoleMember> listOriginalRoleMember = null;
        if (listInductionRecord != null && listInductionRecord.size() > 0) {
            BatchQueryBeginMemberListReq batchQueryBeginMemberListReq = new BatchQueryBeginMemberListReq();
            batchQueryBeginMemberListReq.setBeginMemberList(listInductionRecord.stream()
                    .map(item -> item.getOriginalRoleMemberId())
                    .collect(Collectors.toList()));//sourceId:46456_1
            batchQueryBeginMemberListReq.setIsInvalid("FALSE");//sourceId:46459_1
            batchQueryBeginMemberListReq.setIsTransaction("FALSE");//sourceId:51028_1
            batchQueryBeginMemberListReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:46460_1

            /*1-2-09批量查询身份人员列表	[1181]   */
            listOriginalRoleMember = mOriginalRoleMemberService.batchQueryBeginMemberList(batchQueryBeginMemberListReq);


        }

//步骤2: 1-2-10批量查询身份人员资料列表 - batchQueryBeginMembInfoList
        List<OriginalRoleMemberInfo> listOriginalRoleMemberInfo = null;
        if (listOriginalRoleMember != null && listOriginalRoleMember.size() > 0) {
            BatchQueryBeginMembInfoListReq batchQueryBeginMembInfoListReq = new BatchQueryBeginMembInfoListReq();
            batchQueryBeginMembInfoListReq.setBeginMembInfoList(listOriginalRoleMember.stream()
                    .map(item -> item.getOriginalRoleMemberId())
                    .collect(Collectors.toList()));//sourceId:46462_1

            /*1-2-10批量查询身份人员资料列表[1014]   */
            listOriginalRoleMemberInfo = mOriginalRoleMemberInfoService.batchQueryBeginMembInfoList(batchQueryBeginMembInfoListReq);


        }

//步骤3: 1-2-02批量查询个人资料列表 - batchQueryUserinfoList
        List<Userinfo> listUserinfo = null;
        if (listOriginalRoleMember != null && listOriginalRoleMember.size() > 0) {
            BatchQueryUserinfoListReq batchQueryUserinfoListReq = new BatchQueryUserinfoListReq();
            batchQueryUserinfoListReq.setUserList(listOriginalRoleMember.stream()
                    .map(item -> item.getUserId())
                    .collect(Collectors.toList()));//sourceId:46463_1

            /*1-2-02批量查询个人资料列表[52]   */
            listUserinfo = mUserinfoService.batchQueryUserinfoList(batchQueryUserinfoListReq);


        }

        QueryDeptDirectStaffListBorderRespDto retData = new QueryDeptDirectStaffListBorderRespDto();
        //sourceId:66758_1


        return retData;
    }

    /**
     * D1-2存档部门管理员[1567]
     * gen by moon at 10/2/2022, 12:12:19 AM
     */
    @Trace(operationName = "D1-2存档部门管理员")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ArchiveDeptAdminRoleRelRespDto archiveDeptAdminRoleRel(ArchiveDeptAdminRoleRelReqDto reqDto) {


        //virtualUsage 1-2-14查询管理的部门详情（查管理的部门）  1164
        ManagedDept managedDept = null;
        QueryManageDeptDetailReq queryManageDeptDetailReq = new QueryManageDeptDetailReq();
        queryManageDeptDetailReq.setDeptId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecDeptId());//CURRENT_DEPTID//sourceId:45182_1_1164
        if (reqDto != null) {
            queryManageDeptDetailReq.setRoleMemberId(reqDto.getRoleMemberId());//SimpleFieldAssign//sourceId:45183_1_1164
        }

        /*1-2-14查询管理的部门详情（查管理的部门）[1087]   */
        Assert.isNull(queryManageDeptDetailReq.getDeptId(), "D1-2存档部门管理员-1-2-14查询管理的部门详情（查管理的部门）-部门ID不能为空", false);
        Assert.isNull(queryManageDeptDetailReq.getRoleMemberId(), "D1-2存档部门管理员-1-2-14查询管理的部门详情（查管理的部门）-角色人员ID不能为空", false);
        managedDept = mManagedDeptService.queryManageDeptDetail(queryManageDeptDetailReq);


//virtualUsage 1-2-14删除管理的部门  1165
        boolean bOOLEAN;
        if (managedDept != null) {
            String string = new String();
            if (managedDept != null) {
                string = managedDept.getManagedDepId();
                ;//SimpleFieldAssign//sourceId:45160_1_1165
            }

            /*1-2-14删除管理的部门[1230]   */
            Assert.isNull(string, "D1-2存档部门管理员-1-2-14删除管理的部门-管理的部门ID不能为空", false);
            bOOLEAN = mManagedDeptService.deleteManageDept(string);


        }
//virtualUsage 1-2-14查询管理的部门列表  1166
        List<ManagedDept> listManagedDept = new ArrayList<>();
        QueryManageDeptListReq queryManageDeptListReq = new QueryManageDeptListReq();
        if (reqDto != null) {
            queryManageDeptListReq.setRoleMemberId(reqDto.getRoleMemberId());//SimpleFieldAssign//sourceId:45186_1_1166
        }

        /*1-2-14查询管理的部门列表[1152]   */
        Assert.isNull(queryManageDeptListReq.getRoleMemberId(), "D1-2存档部门管理员-1-2-14查询管理的部门列表-角色人员ID不能为空", false);
        Assert.isNull(queryManageDeptListReq.getSpaceId(), "D1-2存档部门管理员-1-2-14查询管理的部门列表-创建于空间ID不能为空", false);
        listManagedDept = mManagedDeptService.queryManageDeptList(queryManageDeptListReq);


        if ((listManagedDept != null && listManagedDept != null && listManagedDept.size() == 0)) {
            //if(1-2-14查询管理的部门列表.管理的部门列表数据集条数 等于 0)  1167

            boolean bOOLEAN_1;
            RoleMember roleMember = new RoleMember();
            roleMember.setSubjectLifeCycle("ARCHIVING");//sourceId:45161_1_1168
            roleMember.setIsArchive("TRUE");//sourceId:45162_1_1168
            roleMember.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:45156_1_1168
            roleMember.setArchiveInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:45150_1_1168
            roleMember.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:45151_1_1168
            roleMember.setArchiveTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:45152_1_1168
            if (reqDto != null) {
                roleMember.setRoleMemberId(reqDto.getRoleMemberId());//SimpleFieldAssign//sourceId:45141_1_1168
            }

            /*1-2-13修改角色人员（存档）[333]   */
            Assert.isNull(roleMember.getRoleMemberId(), "D1-2存档部门管理员-1-2-13修改角色人员（存档）-角色人员ID不能为空", false);
            Assert.isNull(roleMember.getSubjectLifeCycle(), "D1-2存档部门管理员-1-2-13修改角色人员（存档）-主体生命周期不能为空", false);
            Assert.isNull(roleMember.getIsArchive(), "D1-2存档部门管理员-1-2-13修改角色人员（存档）-是否存档不能为空", false);
            Assert.isNull(roleMember.getOperationInductionId(), "D1-2存档部门管理员-1-2-13修改角色人员（存档）-操作人就职记录ID不能为空", false);
            Assert.isNull(roleMember.getArchiveInductionId(), "D1-2存档部门管理员-1-2-13修改角色人员（存档）-存档人就职记录ID不能为空", false);
            Assert.isNull(roleMember.getOperateTime(), "D1-2存档部门管理员-1-2-13修改角色人员（存档）-操作时间不能为空", false);
            Assert.isNull(roleMember.getArchiveTime(), "D1-2存档部门管理员-1-2-13修改角色人员（存档）-存档时间不能为空", false);
            bOOLEAN_1 = mRoleMemberService.updateRoleRel(roleMember);


//processBranchName:正常结束 ,processBranchId:1169

        } else {
            //else  1170

//processBranchName:正常结束 ,processBranchId:1171

        }
        ArchiveDeptAdminRoleRelRespDto retData = new ArchiveDeptAdminRoleRelRespDto();


        return retData;
    }

    /**
     * D1-2新增部门管理员[1564]
     * gen by moon at 10/2/2022, 12:12:02 AM
     */
    @Trace(operationName = "D1-2新增部门管理员")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AddDeptAdminRoleRelRespDto addDeptAdminRoleRel(AddDeptAdminRoleRelReqDto reqDto) {


        String string_1 = null;
        String string_3 = null;
//virtualUsage 1-2-13查询角色人员详情（查角色人员是否存在）  1152
        RoleMember roleMember = null;
        QueryRoleRelDetailReq queryRoleRelDetailReq = new QueryRoleRelDetailReq();
        queryRoleRelDetailReq.setRoleCode("DEPT_ADMIN");//CUSTOM_CONVENTION//sourceId:45017_1_1152
        queryRoleRelDetailReq.setIsArchive("FALSE");//sourceId:45018_1_1152
        if (reqDto != null) {
            queryRoleRelDetailReq.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:45016_1_1152
        }

        /*1-2-13查询角色人员详情（查角色人员是否存在）[335]   */
        Assert.isNull(queryRoleRelDetailReq.getOriginalRoleMemberId(), "D1-2新增部门管理员-1-2-13查询角色人员详情（查角色人员是否存在）-身份人员ID不能为空", false);
        Assert.isNull(queryRoleRelDetailReq.getRoleCode(), "D1-2新增部门管理员-1-2-13查询角色人员详情（查角色人员是否存在）-角色标识不能为空", false);
        Assert.isNull(queryRoleRelDetailReq.getIsArchive(), "D1-2新增部门管理员-1-2-13查询角色人员详情（查角色人员是否存在）-是否存档不能为空", false);
        roleMember = mRoleMemberService.queryRoleRelDetail(queryRoleRelDetailReq);


        if ((roleMember == null)) {
            //if(1-2-13查询角色人员详情（查角色人员是否存在）.出参 等于空 )  1153

            SceneRole sceneRole = null;
            QueryRoleDetailReq queryRoleDetailReq = new QueryRoleDetailReq();
            queryRoleDetailReq.setRoleCode("DEPT_ADMIN");//CUSTOM_CONVENTION//sourceId:45025_1_1156

            /*1-2-08查询角色详情（查询角色ID）[170]   */
            Assert.isNull(queryRoleDetailReq.getRoleCode(), "D1-2新增部门管理员-1-2-08查询角色详情（查询角色ID）-角色标识不能为空", false);
            sceneRole = mSceneRoleService.queryRoleDetail(queryRoleDetailReq);


            String string = null;
            if (sceneRole != null) {
                RoleMember roleMember_2 = new RoleMember();
                roleMember_2.setRoleCode("DEPT_ADMIN");//CUSTOM_CONVENTION//sourceId:45006_1_1157
                roleMember_2.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:45002_1_1157
                roleMember_2.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:45003_1_1157
                roleMember_2.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:45004_1_1157
                if (reqDto != null) {
                    roleMember_2.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:44998_1_1157
                    roleMember_2.setUserId(reqDto.getUserId());//SimpleFieldAssign//sourceId:54486_1_1157
                    roleMember_2.setFirstLetter(reqDto.getFirstLetter());//SimpleFieldAssign//sourceId:45000_1_1157
                }
                if (sceneRole != null) {
                    roleMember_2.setRoleId(sceneRole.getRoleId());//SimpleFieldAssign//sourceId:44999_1_1157
                }

                /*1-2-13新增角色人员[331]   */
                Assert.isNull(roleMember_2.getOriginalRoleMemberId(), "D1-2新增部门管理员-1-2-13新增角色人员-身份人员ID不能为空", false);
                Assert.isNull(roleMember_2.getUserId(), "D1-2新增部门管理员-1-2-13新增角色人员-账号ID不能为空", false);
                Assert.isNull(roleMember_2.getRoleId(), "D1-2新增部门管理员-1-2-13新增角色人员-角色ID不能为空", false);
                Assert.isNull(roleMember_2.getRoleCode(), "D1-2新增部门管理员-1-2-13新增角色人员-角色标识不能为空", false);
                Assert.isNull(roleMember_2.getFirstLetter(), "D1-2新增部门管理员-1-2-13新增角色人员-备注首位字母不能为空", false);
                Assert.isNull(roleMember_2.getSubjectLifeCycle(), "D1-2新增部门管理员-1-2-13新增角色人员-主体生命周期不能为空", false);
                Assert.isNull(roleMember_2.getSpaceId(), "D1-2新增部门管理员-1-2-13新增角色人员-创建于空间ID不能为空", false);
                Assert.isNull(roleMember_2.getAppId(), "D1-2新增部门管理员-1-2-13新增角色人员-创建于联盟应用ID不能为空", false);
                string = mRoleMemberService.addRoleRel(roleMember_2);


                string_1 = string;
            }
            String string_2 = null;
            if (string != null) {
                ManagedDept managedDept = new ManagedDept();
                managedDept.setOrganizationId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecOrganizationId());//CURRENT_ORGID//sourceId:45010_1_1158
                managedDept.setDeptId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecDeptId());//CURRENT_DEPTID//sourceId:45011_1_1158
                if (string != null) {
                    managedDept.setRoleMemberId(string);//SimpleFieldAssign//sourceId:45012_1_1158
                }
                if (reqDto != null) {
                    managedDept.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:45013_1_1158
                }

                /*1-2-14新增管理的部门[1352]   */
                Assert.isNull(managedDept.getOrganizationId(), "D1-2新增部门管理员-1-2-14新增管理的部门-组织ID不能为空", false);
                Assert.isNull(managedDept.getDeptId(), "D1-2新增部门管理员-1-2-14新增管理的部门-部门ID不能为空", false);
                Assert.isNull(managedDept.getRoleMemberId(), "D1-2新增部门管理员-1-2-14新增管理的部门-角色人员ID不能为空", false);
                Assert.isNull(managedDept.getOriginalRoleMemberId(), "D1-2新增部门管理员-1-2-14新增管理的部门-身份人员ID不能为空", false);
                string_2 = mManagedDeptService.addManageDept(managedDept);


                string_3 = string_2;
            }
        } else {
            //else  1154

//异常结束 1155
            throw new BizException("undefined", "undefined", false);
        }
        AddDeptAdminRoleRelRespDto retData = new AddDeptAdminRoleRelRespDto();
        if (string_1 != null) {
            retData.setRoleMemberId(string_1);//SimpleFieldAssign//sourceId:45112_1
        }
        if (string_3 != null) {
            retData.setManagedDepId(string_3);//SimpleFieldAssign//sourceId:45113_1
        }


        return retData;
    }

    /**
     * D1-2查询部门管理员列表[1151]
     * gen by moon at 10/1/2022, 11:59:05 PM
     */
    @Trace(operationName = "D1-2查询部门管理员列表")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryDeptAdminRoleRelListRespDto queryDeptAdminRoleRelList(QueryDeptAdminRoleRelListReqDto reqDto) {


        List<ManagedDept> listManagedDept_1 = new ArrayList<>();
        List<RoleMember> listRoleMember_1 = new ArrayList<>();
        List<OriginalRoleMemberInfo> listOriginalRoleMemberInfo_1 = new ArrayList<>();
        List<Userinfo> listUserinfo_1 = new ArrayList<>();
//步骤0: 1-2-14查询管理的部门列表 - queryManageDeptList
        List<ManagedDept> listManagedDept = new ArrayList<>();
        QueryManageDeptListReq queryManageDeptListReq = new QueryManageDeptListReq();
        if (reqDto != null) {
            queryManageDeptListReq.setDeptId(reqDto.getDeptId());//SimpleFieldAssign//sourceId:44595_1
        }

        /*1-2-14查询管理的部门列表（查询部门管理员）[1152]   */
        Assert.isNull(queryManageDeptListReq.getDeptId(), "D1-2查询部门管理员列表-1-2-14查询管理的部门列表（查询部门管理员）-部门ID不能为空", false);
        listManagedDept = mManagedDeptService.queryManageDeptList(queryManageDeptListReq);


        listManagedDept_1 = listManagedDept;

//步骤1: 1-2-13批量查询角色人员 - batchQueryRoleRel
        List<RoleMember> listRoleMember = new ArrayList<>();
        if (listManagedDept != null && listManagedDept.size() > 0) {
            BatchQueryRoleRelReq batchQueryRoleRelReq = new BatchQueryRoleRelReq();
            batchQueryRoleRelReq.setRoleRelList(listManagedDept.stream().map(item -> item.getRoleMemberId())
                    .collect(Collectors.toList()));/*list-to-strings*///sourceId:44612_1
            batchQueryRoleRelReq.setRelationshipValid("FALSE");//sourceId:44614_1
            batchQueryRoleRelReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:44615_1

            /*1-2-13批量查询角色人员（查询正常数据）[1354]   */
            Assert.isNull(batchQueryRoleRelReq.getRelationshipValid(), "D1-2查询部门管理员列表-1-2-13批量查询角色人员（查询正常数据）-是否失效不能为空", false);
            Assert.isNull(batchQueryRoleRelReq.getSubjectLifeCycle(), "D1-2查询部门管理员列表-1-2-13批量查询角色人员（查询正常数据）-主体生命周期不能为空", false);
            listRoleMember = mRoleMemberService.batchQueryRoleRel(batchQueryRoleRelReq);


            listRoleMember_1 = listRoleMember;
        }

//步骤2: 1-2-10批量查询身份人员资料列表 - batchQueryBeginMembInfoList
        List<OriginalRoleMemberInfo> listOriginalRoleMemberInfo = new ArrayList<>();
        if (listRoleMember != null && listRoleMember.size() > 0) {
            BatchQueryBeginMembInfoListReq batchQueryBeginMembInfoListReq = new BatchQueryBeginMembInfoListReq();
            batchQueryBeginMembInfoListReq.setBeginMembInfoList(listRoleMember.stream().map(item -> item.getOriginalRoleMemberId())
                    .collect(Collectors.toList()));/*list-to-strings*///sourceId:26900_1

            /*1-2-10批量查询身份人员资料列表[1014]   */

            listOriginalRoleMemberInfo = mOriginalRoleMemberInfoService.batchQueryBeginMembInfoList(batchQueryBeginMembInfoListReq);


            listOriginalRoleMemberInfo_1 = listOriginalRoleMemberInfo;
        }

//步骤3: 1-2-02批量查询个人资料列表 - batchQueryUserinfoList
        List<Userinfo> listUserinfo = new ArrayList<>();
        if (listRoleMember != null && listRoleMember.size() > 0) {
            BatchQueryUserinfoListReq batchQueryUserinfoListReq = new BatchQueryUserinfoListReq();
            batchQueryUserinfoListReq.setUserList(listRoleMember.stream().map(item -> item.getUserId())
                    .collect(Collectors.toList()));/*list-to-strings*///sourceId:26881_1

            /*1-2-02批量查询个人资料列表[52]   */

            listUserinfo = mUserinfoService.batchQueryUserinfoList(batchQueryUserinfoListReq);


            listUserinfo_1 = listUserinfo;
        }

        QueryDeptAdminRoleRelListRespDto retData = new QueryDeptAdminRoleRelListRespDto();
        //数据集融合  MoreListToOneSource
        if (listRoleMember_1 != null && !CollectionUtil.isEmpty(listRoleMember_1)) {
            for (RoleMember roleMember : listRoleMember_1) {
                RoleRelDto retElm = new RoleRelDto();
                retElm.setRoleMemberId(roleMember.getRoleMemberId());//SimpleFieldAssign//sourceId:35320_2
                retElm.setOriginalRoleMemberId(roleMember.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:35322_2
                retElm.setUserId(roleMember.getUserId());//SimpleFieldAssign//sourceId:35321_2
                retElm.setRoleId(roleMember.getRoleId());//SimpleFieldAssign//sourceId:36793_2
                retData.getRoleRelList().add(retElm);
                if (listUserinfo_1 != null) {
                    for (Userinfo userinfo : listUserinfo_1) {
                        if (userinfo.getUserId().equals(roleMember.getUserId())) {
                            retElm.setUserFace(userinfo.getUserFace());//SimpleFieldAssign//sourceId:35318_2
                            retElm.setIdCardName(userinfo.getIdCardName());//SimpleFieldAssign//sourceId:35319_2
                            retElm.setNickName(userinfo.getNickName());//SimpleFieldAssign//sourceId:35323_2
                        }
                    }
                }

                if (listOriginalRoleMemberInfo_1 != null) {
                    for (OriginalRoleMemberInfo originalRoleMemberInfo : listOriginalRoleMemberInfo_1) {
                        if (originalRoleMemberInfo.getOriginalRoleMemberId().equals(roleMember.getOriginalRoleMemberId())) {
                            retElm.setRoleMemberCode(originalRoleMemberInfo.getRoleMemberCode());//SimpleFieldAssign//sourceId:35324_2
                            retElm.setPositionIdName(originalRoleMemberInfo.getPositionIdName());//SimpleFieldAssign//sourceId:35325_2
                        }
                    }
                }

            }
        }//sourceId:63320_1


        return retData;
    }

    /**
     * D1-2删除角色人员[1004]
     * gen by moon at 10/15/2022, 5:39:20 PM
     */
    @Trace(operationName = "D1-2删除角色人员")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public DeleteRoleRelRespDto deleteRoleRel(DeleteRoleRelReqDto reqDto) {


        //步骤0: 1-2-13删除角色人员 - deleteRoleRel
        boolean bOOLEAN;
        String string = new String();
        if (reqDto != null) {
            string = reqDto.getRoleMemberId();
            ;//SimpleFieldAssign//sourceId:28117_1
        }

        /*1-2-13删除角色人员[332]   */
        Assert.isNull(string, "D1-2删除角色人员-1-2-13删除角色人员-角色人员ID不能为空", false);
        bOOLEAN = mRoleMemberService.deleteRoleRel(string);


//步骤1: 1-2-14查询管理的部门列表 - queryManageDeptList
        List<ManagedDept> listManagedDept = new ArrayList<>();
        QueryManageDeptListReq queryManageDeptListReq = new QueryManageDeptListReq();
        queryManageDeptListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:330026_1
        if (reqDto != null) {
            queryManageDeptListReq.setRoleMemberId(reqDto.getRoleMemberId());//SimpleFieldAssign//sourceId:330023_1
        }

        /*1-2-14查询管理的部门列表[1152]   */
        Assert.isNull(queryManageDeptListReq.getRoleMemberId(), "D1-2删除角色人员-1-2-14查询管理的部门列表-角色人员ID不能为空", false);
        Assert.isNull(queryManageDeptListReq.getSpaceId(), "D1-2删除角色人员-1-2-14查询管理的部门列表-创建于空间ID不能为空", false);
        listManagedDept = mManagedDeptService.queryManageDeptList(queryManageDeptListReq);


//步骤2: 1-2-14批量删除管理的部门 - batchDeleteManageDept
        boolean bOOLEAN_1;
        if (listManagedDept != null && !CollectionUtil.isEmpty(listManagedDept) && listManagedDept.size() > 0) {
            List<String> listString = new ArrayList<>();
            listString = listManagedDept.stream().map(item -> item.getManagedDepId())
                    .collect(Collectors.toList());/*list-to-strings*///sourceId:330020_1

            /*1-2-14批量删除管理的部门[1131]   */

            bOOLEAN_1 = mManagedDeptService.batchDeleteManageDept(listString);


        }

        DeleteRoleRelRespDto retData = new DeleteRoleRelRespDto();


        return retData;
    }

    /**
     * D1-2修改角色人员[1001]
     */
    @Trace(operationName = "D1-2修改角色人员")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public UpdateRoleRelRespDto updateRoleRel(UpdateRoleRelReqDto reqDto) {


        //步骤0: 1-2-13修改角色人员 - updateRoleRel
        boolean bOOLEAN;
        RoleMember roleMember = new RoleMember();
        roleMember.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:31789_1
        if (roleMember != null && roleMember.getSubjectLifeCycle().equals("CURRENTLY_VALID")) {
            roleMember.setReleaseInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//RELEASED_CURRENT_INDUCTIONID
        }//sourceId:31782_1
        if (roleMember != null && roleMember.getSubjectLifeCycle().equals("ARCHIVING")) {
            roleMember.setArchiveInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//ARCHIVE_CURRENT_INDUCTIONID
        }//sourceId:31783_1
        roleMember.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:31784_1
        if (roleMember != null && roleMember.getSubjectLifeCycle().equals("ARCHIVING")) {
            roleMember.setArchiveTime(CommonFunctionHelper.getCurrentTime());//HISTORICAL_ARCHIVING
        }//sourceId:31785_1
        if (roleMember != null && roleMember.getSubjectLifeCycle().equals("CURRENTLY_VALID")) {
            roleMember.setReleaseTime(CommonFunctionHelper.getCurrentTime());//RELEASE_SYSTEM_CURRENT_TIME
        }//sourceId:31786_1
        roleMember.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:31787_1
        roleMember.setAppId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:31788_1
        if (reqDto != null) {
            roleMember.setRoleMemberId(reqDto.getRoleMemberId());//sourceId:31774_1
            roleMember.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//sourceId:31790_1
            roleMember.setRelationshipValid(reqDto.getRelationshipValid());//sourceId:31775_1
            roleMember.setStatus(reqDto.getStatus());//sourceId:31776_1
            roleMember.setInvalidReason(reqDto.getInvalidReason());//sourceId:31777_1
            roleMember.setInvalidTime(reqDto.getInvalidTime());//sourceId:31778_1
            roleMember.setFirstLetter(reqDto.getFirstLetter());//sourceId:31779_1
            roleMember.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//sourceId:31780_1
            roleMember.setIsArchive(reqDto.getIsArchive());//sourceId:31781_1
        }

        /*1-2-13修改角色人员[333]   */
        bOOLEAN = mRoleMemberService.updateRoleRel(roleMember);


        UpdateRoleRelRespDto retData = new UpdateRoleRelRespDto();


        return retData;
    }

    /**
     * D1-2删除部门管理员(管理)[1136]
     * gen by moon at 8/10/2022, 3:14:32 AM
     */
    @Trace(operationName = "D1-2删除部门管理员(管理)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @BanAuto
    @Override
    public DeleteDeptAdminRoleRelRespDto deleteDeptAdminRoleRel(DeleteDeptAdminRoleRelReqDto reqDto) {


        //步骤0: 1-2-14查询管理的部门列表 - queryManageDeptList
        List<ManagedDept> listManagedDept = new ArrayList<>();
        QueryManageDeptListReq queryManageDeptListReq = new QueryManageDeptListReq();
        if (reqDto != null) {
            queryManageDeptListReq.setRoleMemberId(reqDto.getRoleMemberId());//sourceId:28860_1
        }

        /*1-2-14查询管理的部门列表[1152]   */

        listManagedDept = mManagedDeptService.queryManageDeptList(queryManageDeptListReq);


//步骤1: 1-2-14批量删除管理的部门 - batchDeleteManageDept
        boolean bOOLEAN;
        if (listManagedDept != null && listManagedDept.size() > 0) {
            List<String> batchDeleteManageDeptReq = new ArrayList<>();
            // TODO: 2022/9/16 晓东，这个地方要看下，写法要注意
//  batchDeleteManageDeptReq.setManagedDeptList(listManagedDept.stream().map(item->item.getManagedDepId())
//        .collect(Collectors.toList()));//sourceId:28126_1
            batchDeleteManageDeptReq = listManagedDept.stream().map(item -> item.getManagedDepId())
                    .collect(Collectors.toList());

            /*1-2-14批量删除管理的部门[1131]   */

            bOOLEAN = mManagedDeptService.batchDeleteManageDept(batchDeleteManageDeptReq);


        }

//步骤2: 1-2-13删除角色人员 - deleteRoleRel
        boolean bOOLEAN_1;
        String string = new String();
        if (reqDto != null) {
            string = reqDto.getRoleMemberId();
            ;//sourceId:23437_1
        }

        /*1-2-13删除角色人员[332]   */
        Assert.isNull(string, "D1-2删除部门管理员(管理)-1-2-13删除角色人员-角色人员ID不能为空", false);
        bOOLEAN_1 = mRoleMemberService.deleteRoleRel(string);


        DeleteDeptAdminRoleRelRespDto retData = new DeleteDeptAdminRoleRelRespDto();


        return retData;
    }

    /**
     * D1-2查询角色标识匹配结果详情[3775]
     * gen by moon at 10/2/2022, 3:58:42 AM
     */
    @Trace(operationName = "D1-2查询角色标识匹配结果详情")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryRoleCodeMatchingResultsDetailRespDto queryRoleCodeMatchingResultsDetail(QueryRoleCodeMatchingResultsDetailReqDto reqDto) {


        RoleMember roleMember_1 = null;
//步骤0: 1-2-13查询角色人员详情 - queryRoleRelDetail
        RoleMember roleMember = null;
        QueryRoleRelDetailReq queryRoleRelDetailReq = new QueryRoleRelDetailReq();
        queryRoleRelDetailReq.setRelationshipValid("FALSE");//sourceId:179594_1
        queryRoleRelDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:179595_1
        if (reqDto != null) {
            queryRoleRelDetailReq.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:179592_1
            queryRoleRelDetailReq.setRoleCode(reqDto.getRoleCode());//SimpleFieldAssign//sourceId:179593_1
        }

        /*1-2-13查询角色人员详情[335]   */
        Assert.isNull(queryRoleRelDetailReq.getOriginalRoleMemberId(), "D1-2查询角色标识匹配结果详情-1-2-13查询角色人员详情-身份人员ID不能为空", false);
        Assert.isNull(queryRoleRelDetailReq.getRoleCode(), "D1-2查询角色标识匹配结果详情-1-2-13查询角色人员详情-角色标识不能为空", false);
        Assert.isNull(queryRoleRelDetailReq.getRelationshipValid(), "D1-2查询角色标识匹配结果详情-1-2-13查询角色人员详情-是否失效不能为空", false);
        Assert.isNull(queryRoleRelDetailReq.getSubjectLifeCycle(), "D1-2查询角色标识匹配结果详情-1-2-13查询角色人员详情-主体生命周期不能为空", false);
        roleMember = mRoleMemberService.queryRoleRelDetail(queryRoleRelDetailReq);


        roleMember_1 = roleMember;

        QueryRoleCodeMatchingResultsDetailRespDto retData = new QueryRoleCodeMatchingResultsDetailRespDto();
        if (roleMember_1 != null) {
            retData.setRoleMemberId(roleMember_1.getRoleMemberId());//SimpleFieldAssign//sourceId:179606_1
            retData.setRoleId(roleMember_1.getRoleId());//SimpleFieldAssign//sourceId:179607_1
            retData.setRoleCode(roleMember_1.getRoleCode());//SimpleFieldAssign//sourceId:179608_1
        }


        return retData;
    }

    /**
     * D1-2判断用户唯一资料(公共)[4014]
     * gen by moon at 1/24/2024, 3:47:33 AM
     */
    @Trace(operationName = "D1-2判断用户唯一资料(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public JudgeUserOnlyInfoComRespDto judgeUserOnlyInfoCom(JudgeUserOnlyInfoComReqDto reqDto) {


        QueryReceiveFieldDetailRespDto receptionServiceRes_1 = null;
        QueryReceiveFieldDetailRespDto receptionServiceRes_3 = null;
        QueryReceiveFieldDetailRespDto receptionServiceRes_5 = null;
        QueryReceiveFieldDetailRespDto receptionServiceRes_7 = null;
        if ((reqDto != null && reqDto.getRoleMemberCode() != null)) {
            //if(D1-2判断用户唯一资料(公共).身份人员编号 值不等于空 )  13271

            List<OriginalRoleMemberInfo> listOriginalRoleMemberInfo = new ArrayList<>();
            QueryBeginMembInfoListReq queryBeginMembInfoListReq = new QueryBeginMembInfoListReq();
            if (reqDto != null) {
                queryBeginMembInfoListReq.setRoleMemberCode(reqDto.getRoleMemberCode());//SimpleFieldAssign//sourceId:213697_1_13272
            }

            /*1-2-10查询工号是否唯一[4016]   */

            listOriginalRoleMemberInfo = mOriginalRoleMemberInfoService.queryBeginMembInfoList(queryBeginMembInfoListReq)/*vcase invoke 本地 method 方法调用;*/;


            if ((listOriginalRoleMemberInfo != null && listOriginalRoleMemberInfo != null && listOriginalRoleMemberInfo.size() == 0 && listOriginalRoleMemberInfo != null && listOriginalRoleMemberInfo != null && listOriginalRoleMemberInfo.size() == 0)) {
                //if(1-2-10查询工号是否唯一.身份人员资料列表 数据集条数 等于 0)  13286

//ModelCode: receptionService
                QueryReceiveFieldDetailRespDto receptionServiceRes = null;
                QueryReceiveFieldDetailReqDto receptionServiceReq = new QueryReceiveFieldDetailReqDto();
                receptionServiceReq.setInputNum(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:213703_1_13287

                /*M1-有值可操作（工号可用）[3715]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq.getInputNum(), "D1-2判断用户唯一资料(公共)-M1-有值可操作（工号可用）-输入数值（整数型）不能为空", false);
                receptionServiceRes = nbMember.queryReceiveFieldDetail(receptionServiceReq);


                receptionServiceRes_1 = receptionServiceRes;
//processBranchName:正常结束 ,processBranchId:13295

            } else {
                //else  13288

//异常结束 13289
                throw new BizException("10200067", "对不起，该工号已经被使用", false);
            }
        }
        if ((reqDto != null && reqDto.getUserName() != null)) {
            //if(D1-2判断用户唯一资料(公共).用户名 值不等于空 )  13275

            List<Users> listUsers = new ArrayList<>();
            QueryUserListReq queryUserListReq = new QueryUserListReq();
            if (reqDto != null) {
                queryUserListReq.setUserName(reqDto.getUserName());//SimpleFieldAssign//sourceId:213593_1_13276
            }

            /*1-2-01查询用户名唯一性[48]   */

            listUsers = mUsersService.queryUserList(queryUserListReq)/*vcase invoke 本地 method 方法调用;*/;


            if ((listUsers != null && listUsers != null && listUsers.size() == 0)) {
                //if(1-2-01查询用户名唯一性.个人账号列表数据集条数 等于 0)  13290

//ModelCode: receptionService
                QueryReceiveFieldDetailRespDto receptionServiceRes_2 = null;
                QueryReceiveFieldDetailReqDto receptionServiceReq_1 = new QueryReceiveFieldDetailReqDto();
                receptionServiceReq_1.setInputNum(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:213860_1_13306

                /*M1-有值可操作（用户名可用）[3715]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_1.getInputNum(), "D1-2判断用户唯一资料(公共)-M1-有值可操作（用户名可用）-输入数值（整数型）不能为空", false);
                receptionServiceRes_2 = nbMember.queryReceiveFieldDetail(receptionServiceReq_1);


                receptionServiceRes_3 = receptionServiceRes_2;
//processBranchName:正常结束 ,processBranchId:13294

            } else {
                //else  13304

//异常结束 13305
                throw new BizException("10200068", "对不起，该用户名已被使用，请更换其他用户名，谢谢~", false);
            }
        }
        if ((reqDto != null && reqDto.getEmail() != null)) {
            //if(D1-2判断用户唯一资料(公共).绑定邮箱 值不等于空 )  13279

            List<Users> listUsers_2 = new ArrayList<>();
            QueryUserListReq queryUserListReq_1 = new QueryUserListReq();
            if (reqDto != null) {
                queryUserListReq_1.setEmail(reqDto.getEmail());//SimpleFieldAssign//sourceId:213640_1_13280
            }

            /*1-2-01查询邮箱唯一性[48]   */

            listUsers_2 = mUsersService.queryUserList(queryUserListReq_1)/*vcase invoke 本地 method 方法调用;*/;


            if ((listUsers_2 != null && listUsers_2 != null && listUsers_2.size() == 0)) {
                //if(1-2-01查询邮箱唯一性.个人账号列表数据集条数 等于 0)  13291

//ModelCode: receptionService
                QueryReceiveFieldDetailRespDto receptionServiceRes_4 = null;
                QueryReceiveFieldDetailReqDto receptionServiceReq_2 = new QueryReceiveFieldDetailReqDto();
                receptionServiceReq_2.setInputNum(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:213862_1_13307

                /*M1-有值可操作（邮箱可用）[3715]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_2.getInputNum(), "D1-2判断用户唯一资料(公共)-M1-有值可操作（邮箱可用）-输入数值（整数型）不能为空", false);
                receptionServiceRes_4 = nbMember.queryReceiveFieldDetail(receptionServiceReq_2);


                receptionServiceRes_5 = receptionServiceRes_4;
//processBranchName:正常结束 ,processBranchId:13297

            } else {
                //else  13302

//异常结束 13303
                throw new BizException("10200070", "对不起，该邮箱已经被使用，请更换其他邮箱或本人登录换绑邮箱~", false);
            }
        }
        if ((reqDto != null && reqDto.getPhone() != null)) {
            //if(D1-2判断用户唯一资料(公共).绑定手机 值不等于空 )  13283

            List<Users> listUsers_4 = new ArrayList<>();
            QueryUserListReq queryUserListReq_2 = new QueryUserListReq();
            if (reqDto != null) {
                queryUserListReq_2.setPhone(reqDto.getPhone());//SimpleFieldAssign//sourceId:213618_1_13284
            }

            /*1-2-01查询手机号唯一性[48]   */

            listUsers_4 = mUsersService.queryUserList(queryUserListReq_2)/*vcase invoke 本地 method 方法调用;*/;


            if ((listUsers_4 != null && listUsers_4 != null && listUsers_4.size() == 0)) {
                //if(1-2-01查询手机号唯一性.个人账号列表数据集条数 等于 0)  13292

//ModelCode: receptionService
                QueryReceiveFieldDetailRespDto receptionServiceRes_6 = null;
                QueryReceiveFieldDetailReqDto receptionServiceReq_3 = new QueryReceiveFieldDetailReqDto();
                receptionServiceReq_3.setInputNum(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:213865_1_13308

                /*M1-有值可操作（手机号可用）[3715]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_3.getInputNum(), "D1-2判断用户唯一资料(公共)-M1-有值可操作（手机号可用）-输入数值（整数型）不能为空", false);
                receptionServiceRes_6 = nbMember.queryReceiveFieldDetail(receptionServiceReq_3);


                receptionServiceRes_7 = receptionServiceRes_6;
//processBranchName:正常结束 ,processBranchId:13299

            } else {
                //else  13300

//异常结束 13301
                throw new BizException("10200069", "对不起，该手机号已注册，请更换手机号或本人登录换绑手机号~~", false);
            }
        }
        JudgeUserOnlyInfoComRespDto retData = new JudgeUserOnlyInfoComRespDto();
        if (receptionServiceRes_1 != null) {
            retData.setRoleMemberUsableOutputNum(receptionServiceRes_1.getOutputNum());//SimpleFieldAssign//sourceId:213866_1
        }
        if (receptionServiceRes_3 != null) {
            retData.setUserNameUsableOutputNum(receptionServiceRes_3.getOutputNum());//SimpleFieldAssign//sourceId:213867_1
        }
        if (receptionServiceRes_5 != null) {
            retData.setEmailUsableOutputNum(receptionServiceRes_5.getOutputNum());//SimpleFieldAssign//sourceId:213868_1
        }
        if (receptionServiceRes_7 != null) {
            retData.setPhoneUsableOutputNum(receptionServiceRes_7.getOutputNum());//SimpleFieldAssign//sourceId:213869_1
        }


        return retData;
    }

    /**
     * D1判断注册完善员工操作可用(公共)[4015]
     * gen by moon at 10/1/2022, 11:51:45 PM
     */
    @Trace(operationName = "D1判断注册完善员工操作可用(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public JudgeAddPerfectStaffUsableComRespDto judgeAddPerfectStaffUsableCom(JudgeAddPerfectStaffUsableComReqDto reqDto) {


        QueryCurrentUserRolePowerDetailComRespDto queryCurrentUserRolePowerDetailComRespDto_1 = null;
//步骤0: D1-2判断用户唯一资料(公共) - judgeUserOnlyInfoCom
        JudgeUserOnlyInfoComRespDto judgeUserOnlyInfoComRespDto = null;
        JudgeUserOnlyInfoComReqDto judgeUserOnlyInfoComReqDto = new JudgeUserOnlyInfoComReqDto();
        if (reqDto != null) {
            judgeUserOnlyInfoComReqDto.setUserName(reqDto.getUserName());//SimpleFieldAssign//sourceId:213896_1
            judgeUserOnlyInfoComReqDto.setRoleMemberCode(reqDto.getRoleMemberCode());//SimpleFieldAssign//sourceId:213895_1
            judgeUserOnlyInfoComReqDto.setPhone(reqDto.getPhone());//SimpleFieldAssign//sourceId:213898_1
            judgeUserOnlyInfoComReqDto.setEmail(reqDto.getEmail());//SimpleFieldAssign//sourceId:213897_1
        }

        /*D1-2判断用户唯一资料(公共)[4014]   */

        judgeUserOnlyInfoComRespDto = judgeUserOnlyInfoCom(judgeUserOnlyInfoComReqDto);


//步骤1: D1查询当前用户指定角色权限(公共) - queryCurrentUserRolePowerDetailCom
        QueryCurrentUserRolePowerDetailComRespDto queryCurrentUserRolePowerDetailComRespDto = null;
        QueryCurrentUserRolePowerDetailComReqDto queryCurrentUserRolePowerDetailComReqDto = new QueryCurrentUserRolePowerDetailComReqDto();
        if (reqDto != null) {
            queryCurrentUserRolePowerDetailComReqDto.setRoleCode(reqDto.getRoleCode());//SimpleFieldAssign//sourceId:213903_1
            queryCurrentUserRolePowerDetailComReqDto.setPrivacyCode(reqDto.getPrivacyCode());//SimpleFieldAssign//sourceId:213904_1
        }

        /*D1查询当前用户指定角色权限(公共)[3831]   */
        Assert.isNull(queryCurrentUserRolePowerDetailComReqDto.getRoleCode(), "D1判断注册完善员工操作可用(公共)-D1查询当前用户指定角色权限(公共)-角色标识不能为空", false);
        Assert.isNull(queryCurrentUserRolePowerDetailComReqDto.getPrivacyCode(), "D1判断注册完善员工操作可用(公共)-D1查询当前用户指定角色权限(公共)-权限标识不能为空", false);
        queryCurrentUserRolePowerDetailComRespDto = powerService.queryCurrentUserRolePowerDetailCom(queryCurrentUserRolePowerDetailComReqDto);


        queryCurrentUserRolePowerDetailComRespDto_1 = queryCurrentUserRolePowerDetailComRespDto;

        JudgeAddPerfectStaffUsableComRespDto retData = new JudgeAddPerfectStaffUsableComRespDto();
        if (queryCurrentUserRolePowerDetailComRespDto_1 != null) {
            retData.setOutputNum(queryCurrentUserRolePowerDetailComRespDto_1.getOutputNum());//SimpleFieldAssign//sourceId:213910_1
        }


        return retData;
    }

    /**
     * D1-2判断用户唯一资料是否修改(公共)[4394]
     * gen by moon at 6/4/2023, 1:09:53 PM
     */
    @Trace(operationName = "D1-2判断用户唯一资料是否修改(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public JudgeJudgeUserOnlyInfoUpdateComRespDto judgeJudgeUserOnlyInfoUpdateCom(JudgeJudgeUserOnlyInfoUpdateComReqDto reqDto) {


        if ((reqDto != null && reqDto.getUserName() != null)) {
            //if(D1-2判断用户唯一资料是否修改(公共).用户名 值不等于空 )  15770

            Users users = null;
            QueryUserDetailReq queryUserDetailReq = new QueryUserDetailReq();
            queryUserDetailReq.setUserId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecUserId());//CURRENT_USERID//sourceId:307015_1_15771
            if (reqDto != null) {
                queryUserDetailReq.setUserName(reqDto.getUserName());//SimpleFieldAssign//sourceId:308726_1_15771
            }

            /*1-2-01查询个人账号详情[286]   */
            Assert.isNull(queryUserDetailReq.getUserId(), "D1-2判断用户唯一资料是否修改(公共)-1-2-01查询个人账号详情-个人账号不能为空", false);
            users = mUsersService.queryUserDetail(queryUserDetailReq)/*vcase invoke 本地 method 方法调用;*/;


            if ((users == null)) {
                //if(1-2-01查询个人账号详情.出参 值等于空 )  15777

                List<Users> listUsers = new ArrayList<>();
                QueryUserListReq queryUserListReq = new QueryUserListReq();
                if (reqDto != null) {
                    queryUserListReq.setUserName(reqDto.getUserName());//SimpleFieldAssign//sourceId:307996_1_15778
                }

                /*1-2-01查询用户名是否唯一[48]   */

                listUsers = mUsersService.queryUserList(queryUserListReq)/*vcase invoke 本地 method 方法调用;*/;


                if ((listUsers != null && listUsers != null && listUsers.size() == 0)) {
                    //if(1-2-01查询用户名是否唯一.个人账号列表数据集条数 等于 0)  15780

//ModelCode: receptionService
                    QueryReceiveFieldDetailRespDto receptionServiceRes = null;
                    QueryReceiveFieldDetailReqDto receptionServiceReq = new QueryReceiveFieldDetailReqDto();
                    receptionServiceReq.setInputNum(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:308059_1_15781

                    /*M1-有值可操作（用户名可用）[3715]  用于特殊方法接收上游入参。 */

                    receptionServiceRes = nbMember.queryReceiveFieldDetail(receptionServiceReq);


//processBranchName:正常结束 ,processBranchId:15782

                } else {
                    //else  15783

//异常结束 15784
                    throw new BizException("10200068", "对不起，该用户名已被使用，请更换其他用户名，谢谢~", false);
                }
            }
        }
        if ((reqDto != null && reqDto.getPhone() != null)) {
            //if(D1-2判断用户唯一资料是否修改(公共).绑定手机 值不等于空 )  15787

            Users users_2 = null;
            QueryUserDetailReq queryUserDetailReq_1 = new QueryUserDetailReq();
            queryUserDetailReq_1.setUserId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecUserId());//CURRENT_USERID//sourceId:307015_1_15789
            if (reqDto != null) {
                queryUserDetailReq_1.setPhone(reqDto.getPhone());//SimpleFieldAssign//sourceId:308727_1_15789
            }

            /*1-2-01查询个人账号详情[286]   */
            Assert.isNull(queryUserDetailReq_1.getUserId(), "D1-2判断用户唯一资料是否修改(公共)-1-2-01查询个人账号详情-个人账号不能为空", false);
            users_2 = mUsersService.queryUserDetail(queryUserDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;


            if ((users_2 == null)) {
                //if(1-2-01查询个人账号详情.出参 值等于空 )  15790

                List<Users> listUsers_2 = new ArrayList<>();
                QueryUserListReq queryUserListReq_1 = new QueryUserListReq();
                if (reqDto != null) {
                    queryUserListReq_1.setPhone(reqDto.getPhone());//SimpleFieldAssign//sourceId:308003_1_15791
                }

                /*1-2-01查询手机号是否唯一[48]   */

                listUsers_2 = mUsersService.queryUserList(queryUserListReq_1)/*vcase invoke 本地 method 方法调用;*/;


                if ((listUsers_2 != null && listUsers_2 != null && listUsers_2.size() == 0)) {
                    //if(1-2-01查询手机号是否唯一.个人账号列表数据集条数 等于 0)  15792

//ModelCode: receptionService
                    QueryReceiveFieldDetailRespDto receptionServiceRes_2 = null;
                    QueryReceiveFieldDetailReqDto receptionServiceReq_1 = new QueryReceiveFieldDetailReqDto();
                    receptionServiceReq_1.setInputNum(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:308063_1_15793

                    /*M1-有值可操作（手机号可用）[3715]  用于特殊方法接收上游入参。 */

                    receptionServiceRes_2 = nbMember.queryReceiveFieldDetail(receptionServiceReq_1);


//processBranchName:正常结束 ,processBranchId:15794

                } else {
                    //else  15795

//异常结束 15796
                    throw new BizException("10200069", "对不起，该手机号已注册，请更换手机号或本人登录换绑手机号~~", false);
                }
            }
        }
        if ((reqDto != null && reqDto.getRoleMemberCode() != null)) {
            //if(D1-2判断用户唯一资料是否修改(公共).身份人员编号 值不等于空 )  15798

            OriginalRoleMemberInfo originalRoleMemberInfo = null;
            QueryBeginMembInfoDetailReq queryBeginMembInfoDetailReq = new QueryBeginMembInfoDetailReq();
            queryBeginMembInfoDetailReq.setOriginalRoleMemberId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecOriginalRoleMemberId());//CURRENT_ORIGINAL_ROLE_MEMBERID//sourceId:310218_1_15815
            if (reqDto != null) {
                queryBeginMembInfoDetailReq.setRoleMemberCode(reqDto.getRoleMemberCode());//SimpleFieldAssign//sourceId:310232_1_15815
            }

            /*1-2-10查询身份人员资料详情[116]   */
            Assert.isNull(queryBeginMembInfoDetailReq.getOriginalRoleMemberId(), "D1-2判断用户唯一资料是否修改(公共)-1-2-10查询身份人员资料详情-身份人员ID不能为空", false);
            originalRoleMemberInfo = mOriginalRoleMemberInfoService.queryBeginMembInfoDetail(queryBeginMembInfoDetailReq)/*vcase invoke 本地 method 方法调用;*/;


            if ((originalRoleMemberInfo == null)) {
                //if(1-2-10查询身份人员资料详情.出参 值等于空 )  15816

                List<OriginalRoleMemberInfo> listOriginalRoleMemberInfo = new ArrayList<>();
                QueryBeginMembInfoListReq queryBeginMembInfoListReq = new QueryBeginMembInfoListReq();
                if (reqDto != null) {
                    queryBeginMembInfoListReq.setRoleMemberCode(reqDto.getRoleMemberCode());//SimpleFieldAssign//sourceId:308005_1_15817
                }

                /*1-2-10查询工号是否唯一[4016]   */

                listOriginalRoleMemberInfo = mOriginalRoleMemberInfoService.queryBeginMembInfoList(queryBeginMembInfoListReq)/*vcase invoke 本地 method 方法调用;*/;


                if ((listOriginalRoleMemberInfo != null && listOriginalRoleMemberInfo != null && listOriginalRoleMemberInfo.size() == 0)) {
                    //if(1-2-10查询工号是否唯一.身份人员资料列表 数据集条数 等于 0)  15818

//ModelCode: receptionService
                    QueryReceiveFieldDetailRespDto receptionServiceRes_4 = null;
                    QueryReceiveFieldDetailReqDto receptionServiceReq_2 = new QueryReceiveFieldDetailReqDto();
                    receptionServiceReq_2.setInputNum(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:308058_1_15819

                    /*M1-有值可操作（工号可用）[3715]  用于特殊方法接收上游入参。 */

                    receptionServiceRes_4 = nbMember.queryReceiveFieldDetail(receptionServiceReq_2);


//processBranchName:正常结束 ,processBranchId:15820

                } else {
                    //else  15821

//异常结束 15822
                    throw new BizException("10200067", "对不起，该工号已经被使用", false);
                }
            }
        }
        if ((reqDto != null && reqDto.getEmail() != null)) {
            //if(D1-2判断用户唯一资料是否修改(公共).绑定邮箱 值不等于空 )  15799

            Users users_3 = null;
            QueryUserDetailReq queryUserDetailReq_2 = new QueryUserDetailReq();
            queryUserDetailReq_2.setUserId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecUserId());//CURRENT_USERID//sourceId:307015_1_15801
            if (reqDto != null) {
                queryUserDetailReq_2.setEmail(reqDto.getEmail());//SimpleFieldAssign//sourceId:309449_1_15801
            }

            /*1-2-01查询个人账号详情[286]   */
            Assert.isNull(queryUserDetailReq_2.getUserId(), "D1-2判断用户唯一资料是否修改(公共)-1-2-01查询个人账号详情-个人账号不能为空", false);
            users_3 = mUsersService.queryUserDetail(queryUserDetailReq_2)/*vcase invoke 本地 method 方法调用;*/;


            if ((users_3 == null)) {
                //if(1-2-01查询个人账号详情.出参 值等于空 )  15802

                List<Users> listUsers_4 = new ArrayList<>();
                QueryUserListReq queryUserListReq_2 = new QueryUserListReq();
                if (reqDto != null) {
                    queryUserListReq_2.setEmail(reqDto.getEmail());//SimpleFieldAssign//sourceId:308055_1_15823
                }

                /*1-2-01查询邮箱是否唯一[48]   */

                listUsers_4 = mUsersService.queryUserList(queryUserListReq_2)/*vcase invoke 本地 method 方法调用;*/;


                if ((listUsers_4 != null && listUsers_4 != null && listUsers_4.size() == 0)) {
                    //if(1-2-01查询邮箱是否唯一.个人账号列表数据集条数 等于 0)  15824

//ModelCode: receptionService
                    QueryReceiveFieldDetailRespDto receptionServiceRes_6 = null;
                    QueryReceiveFieldDetailReqDto receptionServiceReq_3 = new QueryReceiveFieldDetailReqDto();
                    receptionServiceReq_3.setInputNum(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:308062_1_15825

                    /*M1-有值可操作（邮箱可用）[3715]  用于特殊方法接收上游入参。 */

                    receptionServiceRes_6 = nbMember.queryReceiveFieldDetail(receptionServiceReq_3);


//processBranchName:正常结束 ,processBranchId:15826

                } else {
                    //else  15827

//异常结束 15828
                    throw new BizException("10200070", "对不起，该邮箱已经被使用，请更换其他邮箱或本人登录换绑邮箱~", false);
                }
            }
        }
        JudgeJudgeUserOnlyInfoUpdateComRespDto retData = new JudgeJudgeUserOnlyInfoUpdateComRespDto();


        return retData;
    }

    /**
     * D1-2批量查角色人员(边界)[2973]
     * gen by moon at 5/23/2024, 11:28:18 PM
     */
    @Trace(operationName = "D1-2批量查角色人员(边界)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public BatchQueryRoleRelBorderRespDto batchQueryRoleRelBorder(BatchQueryRoleRelBorderReqDto reqDto) {


        List<RoleMember> listRoleMember_1 = new ArrayList<>();
        List<Userinfo> listUserinfo_1 = new ArrayList<>();
//步骤0: 1-2-13批量查询角色人员 - batchQueryRoleRel
        List<RoleMember> listRoleMember = new ArrayList<>();
        BatchQueryRoleRelReq batchQueryRoleRelReq = new BatchQueryRoleRelReq();
        batchQueryRoleRelReq.setRelationshipValid("FALSE");//sourceId:95733_1
        batchQueryRoleRelReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:95734_1
        batchQueryRoleRelReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:95744_1
        if (reqDto != null) {
            batchQueryRoleRelReq.setRoleRelList(reqDto.getRoleRelList());//list-field-assign//sourceId:95731_1
        }

        /*1-2-13批量查询角色人员[1354]   */
        Assert.isNull(batchQueryRoleRelReq.getRelationshipValid(), "D1-2批量查角色人员(边界)-1-2-13批量查询角色人员-是否失效不能为空", false);
        Assert.isNull(batchQueryRoleRelReq.getSubjectLifeCycle(), "D1-2批量查角色人员(边界)-1-2-13批量查询角色人员-主体生命周期不能为空", false);
        Assert.isNull(batchQueryRoleRelReq.getSpaceId(), "D1-2批量查角色人员(边界)-1-2-13批量查询角色人员-创建于空间ID不能为空", false);
        listRoleMember = mRoleMemberService.batchQueryRoleRel(batchQueryRoleRelReq)/*vcase invoke 本地 method 方法调用;*/;


        listRoleMember_1 = listRoleMember;

//步骤1: 1-2-02批量查询个人资料列表 - batchQueryUserinfoList
        List<Userinfo> listUserinfo = new ArrayList<>();
        if (listRoleMember != null && !CollectionUtil.isEmpty(listRoleMember) && listRoleMember.size() > 0) {
            BatchQueryUserinfoListReq batchQueryUserinfoListReq = new BatchQueryUserinfoListReq();
            if (listRoleMember != null && !CollectionUtil.isEmpty(listRoleMember) && listRoleMember != null && !CollectionUtil.isEmpty(listRoleMember)) {
                batchQueryUserinfoListReq.setUserList(listRoleMember.stream().map(item -> item.getUserId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:95745_1
            }

            /*1-2-02批量查询个人资料列表[52]   */

            listUserinfo = mUserinfoService.batchQueryUserinfoList(batchQueryUserinfoListReq)/*vcase invoke 本地 method 方法调用;*/;


            listUserinfo_1 = listUserinfo;
        }

        BatchQueryRoleRelBorderRespDto retData = new BatchQueryRoleRelBorderRespDto();
        //数据集融合  MoreListToOneSource
        if (listRoleMember_1 != null && !CollectionUtil.isEmpty(listRoleMember_1) && !CollectionUtil.isEmpty(listRoleMember_1)) {
            for (RoleMember roleMember : listRoleMember_1) {
                RoleRelDto retElm = new RoleRelDto();
                retElm.setRoleMemberId(roleMember.getRoleMemberId());//SimpleFieldAssign//sourceId:53904_2
                retElm.setOriginalRoleMemberId(roleMember.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:53906_2
                retElm.setRoleCode(roleMember.getRoleCode());//SimpleFieldAssign//sourceId:53908_2
                retElm.setUserId(roleMember.getUserId());//SimpleFieldAssign//sourceId:53905_2
                retData.getRoleRelList().add(retElm);
                if (listUserinfo_1 != null && !CollectionUtil.isEmpty(listUserinfo_1)) {
                    for (Userinfo userinfo : listUserinfo_1) {
                        if (userinfo.getUserId().equals(roleMember.getUserId())) {
                            retElm.setUserFace(userinfo.getUserFace());//SimpleFieldAssign//sourceId:53913_2
                            retElm.setIdCardName(userinfo.getIdCardName());//SimpleFieldAssign//sourceId:53911_2
                            retElm.setNickName(userinfo.getNickName());//SimpleFieldAssign//sourceId:53912_2
                        }
                    }
                }

            }
        }//sourceId:95752_1


        return retData;
    }

    /**
     * D1-2查询字母身份人员列表[4559]
     * gen by moon at 5/23/2024, 11:28:24 PM
     */
    @Trace(operationName = "D1-2查询字母身份人员列表")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryLetterBeginMemberListRespDto queryLetterBeginMemberList(QueryLetterBeginMemberListReqDto reqDto) {


        List<OriginalRoleMember> listOriginalRoleMember_1 = new ArrayList<>();
        List<Userinfo> listUserinfo_3 = new ArrayList<>();
        List<OriginalRoleMemberInfo> listOriginalRoleMemberInfo_1 = new ArrayList<>();
        List<OriginalRoleMember> listOriginalRoleMember_3 = new ArrayList<>();
        if ((reqDto != null && reqDto.getIdCardName() != null)) {
            //if(D1-2查询字母身份人员列表.真实姓名 值不等于空 )  16237

            List<Userinfo> listUserinfo = new ArrayList<>();
            QueryUserInfoListReq queryUserInfoListReq = new QueryUserInfoListReq();
            if (reqDto != null) {
                queryUserInfoListReq.setIdCardName(reqDto.getIdCardName());//SimpleFieldAssign//sourceId:328979_1_16238
            }

            /*1-2-02查询个人资料列表（真实姓名搜索）[1178]   */
            Assert.isNull(queryUserInfoListReq.getIdCardName(), "D1-2查询字母身份人员列表-1-2-02查询个人资料列表（真实姓名搜索）-真实姓名不能为空", false);
            listUserinfo = mUserinfoService.queryUserInfoList(queryUserInfoListReq)/*vcase invoke 本地 method 方法调用;*/;


            List<OriginalRoleMember> listOriginalRoleMember = new ArrayList<>();
            if (listUserinfo != null && !CollectionUtil.isEmpty(listUserinfo) && listUserinfo.size() > 0) {
                BatchQueryStaffBeginMemberListReq batchQueryStaffBeginMemberListReq = new BatchQueryStaffBeginMemberListReq();
                batchQueryStaffBeginMemberListReq.setRoleCode("STAFF");//CUSTOM_CONVENTION//sourceId:329000_1_16239
                if (listUserinfo != null && !CollectionUtil.isEmpty(listUserinfo) && listUserinfo != null && !CollectionUtil.isEmpty(listUserinfo)) {
                    batchQueryStaffBeginMemberListReq.setStaffBeginMemberList(listUserinfo.stream().map(item -> item.getUserId())
                            .collect(Collectors.toList()));/*list-to-strings*///sourceId:328988_1_16239
                }
                if (reqDto != null) {
                    batchQueryStaffBeginMemberListReq.setFirstLetter(reqDto.getFirstLetter());//SimpleFieldAssign//sourceId:328996_1_16239
                    batchQueryStaffBeginMemberListReq.setSource(reqDto.getSource());//SimpleFieldAssign//sourceId:328991_1_16239
                    batchQueryStaffBeginMemberListReq.setIsInvalid(reqDto.getIsInvalid());//SimpleFieldAssign//sourceId:328992_1_16239
                    batchQueryStaffBeginMemberListReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:328993_1_16239
                }

                /*1-2-09批量查询员工身份人员列表[1259]   */
                Assert.isNull(batchQueryStaffBeginMemberListReq.getRoleCode(), "D1-2查询字母身份人员列表-1-2-09批量查询员工身份人员列表-身份角色编码不能为空", false);
                Assert.isNull(batchQueryStaffBeginMemberListReq.getSpaceId(), "D1-2查询字母身份人员列表-1-2-09批量查询员工身份人员列表-创建于空间ID不能为空", false);
                listOriginalRoleMember = mOriginalRoleMemberService.batchQueryStaffBeginMemberList(batchQueryStaffBeginMemberListReq)/*vcase invoke 本地 method 方法调用;*/;


                listOriginalRoleMember_1 = listOriginalRoleMember;
            }
            List<Userinfo> listUserinfo_2 = new ArrayList<>();
            if (listOriginalRoleMember != null && !CollectionUtil.isEmpty(listOriginalRoleMember) && listOriginalRoleMember.size() > 0) {
                BatchQueryUserinfoListReq batchQueryUserinfoListReq = new BatchQueryUserinfoListReq();
                if (listOriginalRoleMember != null && !CollectionUtil.isEmpty(listOriginalRoleMember) && listOriginalRoleMember != null && !CollectionUtil.isEmpty(listOriginalRoleMember)) {
                    batchQueryUserinfoListReq.setUserList(listOriginalRoleMember.stream().map(item -> item.getUserId())
                            .collect(Collectors.toList()));/*list-to-strings*///sourceId:329017_1_16240
                }

                /*1-2-02批量查询个人资料列表[52]   */

                listUserinfo_2 = mUserinfoService.batchQueryUserinfoList(batchQueryUserinfoListReq)/*vcase invoke 本地 method 方法调用;*/;


                listUserinfo_3 = listUserinfo_2;
            }
            List<OriginalRoleMemberInfo> listOriginalRoleMemberInfo = new ArrayList<>();
            if (listOriginalRoleMember != null && !CollectionUtil.isEmpty(listOriginalRoleMember) && listOriginalRoleMember.size() > 0) {
                BatchQueryBeginMembInfoListReq batchQueryBeginMembInfoListReq = new BatchQueryBeginMembInfoListReq();
                if (listOriginalRoleMember != null && !CollectionUtil.isEmpty(listOriginalRoleMember) && listOriginalRoleMember != null && !CollectionUtil.isEmpty(listOriginalRoleMember)) {
                    batchQueryBeginMembInfoListReq.setBeginMembInfoList(listOriginalRoleMember.stream().map(item -> item.getOriginalRoleMemberId())
                            .collect(Collectors.toList()));/*list-to-strings*///sourceId:329022_1_16241
                }
                if (reqDto != null) {
                    batchQueryBeginMembInfoListReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:329023_1_16241
                }

                /*1-2-10批量查询身份人员资料列表[1014]   */
                Assert.isNull(batchQueryBeginMembInfoListReq.getSpaceId(), "D1-2查询字母身份人员列表-1-2-10批量查询身份人员资料列表-创建于空间ID不能为空", false);
                listOriginalRoleMemberInfo = mOriginalRoleMemberInfoService.batchQueryBeginMembInfoList(batchQueryBeginMembInfoListReq)/*vcase invoke 本地 method 方法调用;*/;


                listOriginalRoleMemberInfo_1 = listOriginalRoleMemberInfo;
            }
//processBranchName:正常结束 ,processBranchId:16242

        } else {
            //else  16243

            List<OriginalRoleMember> listOriginalRoleMember_2 = new ArrayList<>();
            QueryBeginMemberListReq queryBeginMemberListReq = new QueryBeginMemberListReq();
            queryBeginMemberListReq.setRoleCode("STAFF");//CUSTOM_CONVENTION//sourceId:329179_1_16244
            if (reqDto != null) {
                queryBeginMemberListReq.setFirstLetter(reqDto.getFirstLetter());//SimpleFieldAssign//sourceId:329180_1_16244
                queryBeginMemberListReq.setSource(reqDto.getSource());//SimpleFieldAssign//sourceId:329181_1_16244
                queryBeginMemberListReq.setIsInvalid(reqDto.getIsInvalid());//SimpleFieldAssign//sourceId:329182_1_16244
                queryBeginMemberListReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:329183_1_16244
            }

            /*1-2-09查询身份人员列表（非搜索）[80]   */
            Assert.isNull(queryBeginMemberListReq.getRoleCode(), "D1-2查询字母身份人员列表-1-2-09查询身份人员列表（非搜索）-身份角色编码不能为空", false);
            Assert.isNull(queryBeginMemberListReq.getSpaceId(), "D1-2查询字母身份人员列表-1-2-09查询身份人员列表（非搜索）-创建于空间ID不能为空", false);
            listOriginalRoleMember_2 = mOriginalRoleMemberService.queryBeginMemberList(queryBeginMemberListReq)/*vcase invoke 本地 method 方法调用;*/;


            listOriginalRoleMember_3 = listOriginalRoleMember_2;
            List<Userinfo> listUserinfo_4 = new ArrayList<>();
            if (listOriginalRoleMember_2 != null && !CollectionUtil.isEmpty(listOriginalRoleMember_2) && listOriginalRoleMember_2.size() > 0) {
                BatchQueryUserinfoListReq batchQueryUserinfoListReq_1 = new BatchQueryUserinfoListReq();
                if (listOriginalRoleMember_2 != null && !CollectionUtil.isEmpty(listOriginalRoleMember_2) && listOriginalRoleMember_2 != null && !CollectionUtil.isEmpty(listOriginalRoleMember_2)) {
                    batchQueryUserinfoListReq_1.setUserList(listOriginalRoleMember_2.stream().map(item -> item.getUserId())
                            .collect(Collectors.toList()));/*list-to-strings*///sourceId:329017_1_16245
                }

                /*1-2-02批量查询个人资料列表[52]   */

                listUserinfo_4 = mUserinfoService.batchQueryUserinfoList(batchQueryUserinfoListReq_1)/*vcase invoke 本地 method 方法调用;*/;


                listUserinfo_3 = listUserinfo_4;
            }
            List<OriginalRoleMemberInfo> listOriginalRoleMemberInfo_2 = new ArrayList<>();
            if (listOriginalRoleMember_2 != null && !CollectionUtil.isEmpty(listOriginalRoleMember_2) && listOriginalRoleMember_2.size() > 0) {
                BatchQueryBeginMembInfoListReq batchQueryBeginMembInfoListReq_1 = new BatchQueryBeginMembInfoListReq();
                if (listOriginalRoleMember_2 != null && !CollectionUtil.isEmpty(listOriginalRoleMember_2) && listOriginalRoleMember_2 != null && !CollectionUtil.isEmpty(listOriginalRoleMember_2)) {
                    batchQueryBeginMembInfoListReq_1.setBeginMembInfoList(listOriginalRoleMember_2.stream().map(item -> item.getOriginalRoleMemberId())
                            .collect(Collectors.toList()));/*list-to-strings*///sourceId:329022_1_16246
                }
                if (reqDto != null) {
                    batchQueryBeginMembInfoListReq_1.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:329023_1_16246
                }

                /*1-2-10批量查询身份人员资料列表[1014]   */
                Assert.isNull(batchQueryBeginMembInfoListReq_1.getSpaceId(), "D1-2查询字母身份人员列表-1-2-10批量查询身份人员资料列表-创建于空间ID不能为空", false);
                listOriginalRoleMemberInfo_2 = mOriginalRoleMemberInfoService.batchQueryBeginMembInfoList(batchQueryBeginMembInfoListReq_1)/*vcase invoke 本地 method 方法调用;*/;


                listOriginalRoleMemberInfo_1 = listOriginalRoleMemberInfo_2;
            }
//processBranchName:正常结束 ,processBranchId:16247

        }
        QueryLetterBeginMemberListRespDto retData = new QueryLetterBeginMemberListRespDto();
        //数据集融合  MoreListToOneSource
        if (listOriginalRoleMember_1 != null && !CollectionUtil.isEmpty(listOriginalRoleMember_1) && !CollectionUtil.isEmpty(listOriginalRoleMember_1)) {
            for (OriginalRoleMember originalRoleMember : listOriginalRoleMember_1) {
                BeginMemberDto retElm = new BeginMemberDto();
                retElm.setOriginalRoleMemberId(originalRoleMember.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:97505_2
                retElm.setUserId(originalRoleMember.getUserId());//SimpleFieldAssign//sourceId:97506_2
                retElm.setIsInvalid(originalRoleMember.getIsInvalid());//SimpleFieldAssign//sourceId:97508_2
                retElm.setFirstLetter(originalRoleMember.getFirstLetter());//SimpleFieldAssign//sourceId:97507_2
                retData.getBeginMemberList().add(retElm);
                if (listUserinfo_3 != null && !CollectionUtil.isEmpty(listUserinfo_3)) {
                    for (Userinfo userinfo : listUserinfo_3) {
                        if (userinfo.getUserId().equals(originalRoleMember.getUserId())) {
                            retElm.setIdCardName(userinfo.getIdCardName());//SimpleFieldAssign//sourceId:97509_2
                            retElm.setNickName(userinfo.getNickName());//SimpleFieldAssign//sourceId:97510_2
                            retElm.setUserFace(userinfo.getUserFace());//SimpleFieldAssign//sourceId:97511_2
                        }
                    }
                }

                if (listOriginalRoleMemberInfo_1 != null && !CollectionUtil.isEmpty(listOriginalRoleMemberInfo_1)) {
                    for (OriginalRoleMemberInfo originalRoleMemberInfo : listOriginalRoleMemberInfo_1) {
                        if (originalRoleMemberInfo.getOriginalRoleMemberId().equals(originalRoleMember.getOriginalRoleMemberId())) {
                            retElm.setRoleMemberCode(originalRoleMemberInfo.getRoleMemberCode());//SimpleFieldAssign//sourceId:97512_2
                            retElm.setPositionIdName(originalRoleMemberInfo.getPositionIdName());//SimpleFieldAssign//sourceId:97513_2
                        }
                    }
                }

            }
        }
//数据集融合  MoreListToOneSource
        if (listOriginalRoleMember_3 != null && !CollectionUtil.isEmpty(listOriginalRoleMember_3) && !CollectionUtil.isEmpty(listOriginalRoleMember_3)) {
            for (OriginalRoleMember originalRoleMember : listOriginalRoleMember_3) {
                BeginMemberDto retElm = new BeginMemberDto();
                retElm.setOriginalRoleMemberId(originalRoleMember.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:97505_2
                retElm.setUserId(originalRoleMember.getUserId());//SimpleFieldAssign//sourceId:97506_2
                retElm.setIsInvalid(originalRoleMember.getIsInvalid());//SimpleFieldAssign//sourceId:97508_2
                retElm.setFirstLetter(originalRoleMember.getFirstLetter());//SimpleFieldAssign//sourceId:97507_2
                retData.getBeginMemberList().add(retElm);
                if (listUserinfo_3 != null && !CollectionUtil.isEmpty(listUserinfo_3)) {
                    for (Userinfo userinfo : listUserinfo_3) {
                        if (userinfo.getUserId().equals(originalRoleMember.getUserId())) {
                            retElm.setIdCardName(userinfo.getIdCardName());//SimpleFieldAssign//sourceId:97509_2
                            retElm.setNickName(userinfo.getNickName());//SimpleFieldAssign//sourceId:97510_2
                            retElm.setUserFace(userinfo.getUserFace());//SimpleFieldAssign//sourceId:97511_2
                        }
                    }
                }

                if (listOriginalRoleMemberInfo_1 != null && !CollectionUtil.isEmpty(listOriginalRoleMemberInfo_1)) {
                    for (OriginalRoleMemberInfo originalRoleMemberInfo : listOriginalRoleMemberInfo_1) {
                        if (originalRoleMemberInfo.getOriginalRoleMemberId().equals(originalRoleMember.getOriginalRoleMemberId())) {
                            retElm.setRoleMemberCode(originalRoleMemberInfo.getRoleMemberCode());//SimpleFieldAssign//sourceId:97512_2
                            retElm.setPositionIdName(originalRoleMemberInfo.getPositionIdName());//SimpleFieldAssign//sourceId:97513_2
                        }
                    }
                }

            }
        }//sourceId:329185_1


        return retData;
    }

    /**
     * D1-2存档角色人员[1001]
     * gen by moon at 10/1/2022, 11:56:14 PM
     */
    @Trace(operationName = "D1-2存档角色人员")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ArchiveRoleRelRespDto archiveRoleRel(ArchiveRoleRelReqDto reqDto) {


        //步骤0: 1-2-13修改角色人员 - updateRoleRel
        boolean bOOLEAN;
        RoleMember roleMember = new RoleMember();
        roleMember.setRelationshipValid("TRUE");//sourceId:31775_1
        roleMember.setStatus("OTHER");//sourceId:31776_1
        roleMember.setInvalidTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:31778_1
        roleMember.setSubjectLifeCycle("ARCHIVING");//sourceId:31780_1
        roleMember.setIsArchive("TRUE");//sourceId:31781_1
        roleMember.setOperationInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:31789_1
        if (roleMember != null && roleMember.getSubjectLifeCycle() != null && roleMember.getSubjectLifeCycle().equals("ARCHIVING")) {
            roleMember.setArchiveInductionId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//ARCHIVE_CURRENT_INDUCTIONID
        }//sourceId:31783_1
        roleMember.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:31784_1
        if (roleMember != null && roleMember.getSubjectLifeCycle() != null && roleMember.getSubjectLifeCycle().equals("ARCHIVING")) {
            roleMember.setArchiveTime(CommonFunctionHelper.getCurrentTime());//HISTORICAL_ARCHIVING
        }//sourceId:31785_1
        if (reqDto != null) {
            roleMember.setRoleMemberId(reqDto.getRoleMemberId());//SimpleFieldAssign//sourceId:31774_1
        }

        /*1-2-13修改角色人员[333]   */
        Assert.isNull(roleMember.getRoleMemberId(), "D1-2存档角色人员-1-2-13修改角色人员-角色人员ID不能为空", false);
        Assert.isNull(roleMember.getRelationshipValid(), "D1-2存档角色人员-1-2-13修改角色人员-是否失效不能为空", false);
        Assert.isNull(roleMember.getStatus(), "D1-2存档角色人员-1-2-13修改角色人员-失效类型不能为空", false);
        Assert.isNull(roleMember.getInvalidTime(), "D1-2存档角色人员-1-2-13修改角色人员-失效时间不能为空", false);
        Assert.isNull(roleMember.getSubjectLifeCycle(), "D1-2存档角色人员-1-2-13修改角色人员-主体生命周期不能为空", false);
        Assert.isNull(roleMember.getIsArchive(), "D1-2存档角色人员-1-2-13修改角色人员-是否存档不能为空", false);
        Assert.isNull(roleMember.getOperationInductionId(), "D1-2存档角色人员-1-2-13修改角色人员-操作人就职记录ID不能为空", false);
        Assert.isNull(roleMember.getOperateTime(), "D1-2存档角色人员-1-2-13修改角色人员-操作时间不能为空", false);
        bOOLEAN = mRoleMemberService.updateRoleRel(roleMember);


//步骤1: 1-2-14查询管理的部门列表 - queryManageDeptList
        List<ManagedDept> listManagedDept = new ArrayList<>();
        QueryManageDeptListReq queryManageDeptListReq = new QueryManageDeptListReq();
        queryManageDeptListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:330051_1
        if (reqDto != null) {
            queryManageDeptListReq.setRoleMemberId(reqDto.getRoleMemberId());//SimpleFieldAssign//sourceId:330037_1
        }

        /*1-2-14查询管理的部门列表[1152]   */
        Assert.isNull(queryManageDeptListReq.getRoleMemberId(), "D1-2存档角色人员-1-2-14查询管理的部门列表-角色人员ID不能为空", false);
        Assert.isNull(queryManageDeptListReq.getSpaceId(), "D1-2存档角色人员-1-2-14查询管理的部门列表-创建于空间ID不能为空", false);
        listManagedDept = mManagedDeptService.queryManageDeptList(queryManageDeptListReq);


//步骤2: 1-2-14批量删除管理的部门 - batchDeleteManageDept
        boolean bOOLEAN_1;
        if (listManagedDept != null && listManagedDept.size() > 0) {
            List<String> listString = new ArrayList<>();
            listString = listManagedDept.stream().map(item -> item.getManagedDepId())
                    .collect(Collectors.toList());/*list-to-strings*///sourceId:330036_1

            /*1-2-14批量删除管理的部门[1131]   */

            bOOLEAN_1 = mManagedDeptService.batchDeleteManageDept(listString);


        }

        ArchiveRoleRelRespDto retData = new ArchiveRoleRelRespDto();


        return retData;
    }

    /**
     * D1-3查询角色人员详情(公共)[5062]
     * gen by moon at 10/28/2022, 11:02:38 PM
     */
    @Trace(operationName = "D1-3查询角色人员详情(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryRoleRelDetailComRespDto queryRoleRelDetailCom(QueryRoleRelDetailComReqDto reqDto) {


        RoleMember roleMember_1 = null;
        Userinfo userinfo_1 = null;
        SceneRole sceneRole_1 = null;
//步骤0: 1-2-13查询角色人员详情 - queryRoleRelDetail
        RoleMember roleMember = null;
        QueryRoleRelDetailReq queryRoleRelDetailReq = new QueryRoleRelDetailReq();
        queryRoleRelDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:408250_1
        if (reqDto != null) {
            queryRoleRelDetailReq.setRoleMemberId(reqDto.getRoleMemberId());//SimpleFieldAssign//sourceId:408249_1
        }

        /*1-2-13查询角色人员详情[335]   */
        Assert.isNull(queryRoleRelDetailReq.getRoleMemberId(), "D1-3查询角色人员详情(公共)-1-2-13查询角色人员详情-角色人员ID不能为空", false);
        Assert.isNull(queryRoleRelDetailReq.getSubjectLifeCycle(), "D1-3查询角色人员详情(公共)-1-2-13查询角色人员详情-主体生命周期不能为空", false);
        roleMember = mRoleMemberService.queryRoleRelDetail(queryRoleRelDetailReq);


        roleMember_1 = roleMember;

//步骤1: 1-2-02查询个人资料详情 - queryUserinfoDetail
        Userinfo userinfo = null;
        if (roleMember != null) {
            QueryUserinfoDetailReq queryUserinfoDetailReq = new QueryUserinfoDetailReq();
            if (roleMember != null) {
                queryUserinfoDetailReq.setUserId(roleMember.getUserId());//SimpleFieldAssign//sourceId:408355_1
            }

            /*1-2-02查询个人资料详情[155]   */
            Assert.isNull(queryUserinfoDetailReq.getUserId(), "D1-3查询角色人员详情(公共)-1-2-02查询个人资料详情-账号不能为空", false);
            userinfo = mUserinfoService.queryUserinfoDetail(queryUserinfoDetailReq);


            userinfo_1 = userinfo;
        }

//步骤2: 1-2-08查询角色详情 - queryRoleDetail
        SceneRole sceneRole = null;
        if (roleMember != null) {
            QueryRoleDetailReq queryRoleDetailReq = new QueryRoleDetailReq();
            if (roleMember != null) {
                queryRoleDetailReq.setRoleId(roleMember.getRoleId());//SimpleFieldAssign//sourceId:408256_1
            }

            /*1-2-08查询角色名称[170]   */
            Assert.isNull(queryRoleDetailReq.getRoleId(), "D1-3查询角色人员详情(公共)-1-2-08查询角色名称-角色ID不能为空", false);
            sceneRole = mSceneRoleService.queryRoleDetail(queryRoleDetailReq);


            sceneRole_1 = sceneRole;
        }

        QueryRoleRelDetailComRespDto retData = new QueryRoleRelDetailComRespDto();
        if (roleMember_1 != null) {
            retData.setRoleMemberId(roleMember_1.getRoleMemberId());//SimpleFieldAssign//sourceId:408364_1
            retData.setRoleId(roleMember_1.getRoleId());//SimpleFieldAssign//sourceId:408366_1
            retData.setRoleCode(roleMember_1.getRoleCode());//SimpleFieldAssign//sourceId:408367_1
            retData.setUserId(roleMember_1.getUserId());//SimpleFieldAssign//sourceId:408365_1
        }
        if (sceneRole_1 != null) {
            retData.setRoleName(sceneRole_1.getRoleName());//SimpleFieldAssign//sourceId:408368_1
        }
        if (userinfo_1 != null) {
            retData.setUserFace(userinfo_1.getUserFace());//SimpleFieldAssign//sourceId:408369_1
            retData.setIdCardName(userinfo_1.getIdCardName());//SimpleFieldAssign//sourceId:408370_1
            retData.setNickName(userinfo_1.getNickName());//SimpleFieldAssign//sourceId:408371_1
            retData.setSex(userinfo_1.getSex());//SimpleFieldAssign//sourceId:408372_1
            retData.setFirstLetter(userinfo_1.getFirstLetter());//SimpleFieldAssign//sourceId:408373_1
        }


        return retData;
    }

    /**
     * D1查询成员个人资料详情(公共)[6778]
     * gen by moon at 1/2/2024, 7:59:50 AM
     */
    @Trace(operationName = "D1查询成员个人资料详情(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryMemberProfileDetailComRespDto queryMemberProfileDetailCom(QueryMemberProfileDetailComReqDto reqDto) {


        OriginalRoleMember originalRoleMember_1 = null;
        Userinfo userinfo_1 = null;
//步骤0: 1-2-09查询身份人员详情 - queryBeginMemberDetail
        OriginalRoleMember originalRoleMember = null;
        QueryBeginMemberDetailReq queryBeginMemberDetailReq = new QueryBeginMemberDetailReq();
        if (reqDto != null) {
            queryBeginMemberDetailReq.setUserId(reqDto.getUserId());//SimpleFieldAssign//sourceId:1159216_1
            queryBeginMemberDetailReq.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:972394_1
            queryBeginMemberDetailReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:972395_1
            queryBeginMemberDetailReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1449682_1
        }

        /*1-2-09查询身份人员详情[174]   */
        Assert.isNull(queryBeginMemberDetailReq.getSpaceId(), "D1查询成员个人资料详情(公共)-1-2-09查询身份人员详情-创建于空间ID不能为空", false);
        originalRoleMember = mOriginalRoleMemberService.queryBeginMemberDetail(queryBeginMemberDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        originalRoleMember_1 = originalRoleMember;

//步骤1: 1-2-02查询个人资料详情 - queryUserinfoDetail
        Userinfo userinfo = null;
        if (originalRoleMember != null) {
            QueryUserinfoDetailReq queryUserinfoDetailReq = new QueryUserinfoDetailReq();
            if (originalRoleMember != null) {
                queryUserinfoDetailReq.setUserId(originalRoleMember.getUserId());//SimpleFieldAssign//sourceId:947533_1
            }

            /*1-2-02查询个人资料详情[155]   */
            Assert.isNull(queryUserinfoDetailReq.getUserId(), "D1查询成员个人资料详情(公共)-1-2-02查询个人资料详情-账号不能为空", false);
            userinfo = mUserinfoService.queryUserinfoDetail(queryUserinfoDetailReq)/*vcase invoke 本地 method 方法调用;*/;


            userinfo_1 = userinfo;
        }

        QueryMemberProfileDetailComRespDto retData = new QueryMemberProfileDetailComRespDto();
        if (userinfo_1 != null) {
            retData.setPersonalDataId(userinfo_1.getPersonalDataId());//SimpleFieldAssign//sourceId:947830_1
            retData.setUserId(userinfo_1.getUserId());//SimpleFieldAssign//sourceId:947831_1
            retData.setIdCardName(userinfo_1.getIdCardName());//SimpleFieldAssign//sourceId:947825_1
            retData.setUserFace(userinfo_1.getUserFace());//SimpleFieldAssign//sourceId:947826_1
            retData.setNickName(userinfo_1.getNickName());//SimpleFieldAssign//sourceId:947832_1
            retData.setUserIntro(userinfo_1.getUserIntro());//SimpleFieldAssign//sourceId:947833_1
            retData.setSex(userinfo_1.getSex());//SimpleFieldAssign//sourceId:947834_1
            retData.setBirthday(userinfo_1.getBirthday());//SimpleFieldAssign//sourceId:947835_1
            retData.setFirstLetter(userinfo_1.getFirstLetter());//SimpleFieldAssign//sourceId:947836_1
            retData.setCity(userinfo_1.getCity());//SimpleFieldAssign//sourceId:947837_1
        }
        if (originalRoleMember_1 != null) {
            retData.setOriginalRoleMemberId(originalRoleMember_1.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1159279_1
            retData.setSpaceId(originalRoleMember_1.getSpaceId());//SimpleFieldAssign//sourceId:994559_1
            retData.setAppId(originalRoleMember_1.getAppId());//SimpleFieldAssign//sourceId:994560_1
        }


        return retData;
    }

    /**
     * D1批量查成员个人资料列表(公共)[7492]
     * gen by moon at 3/27/2024, 10:30:27 PM
     */
    @Trace(operationName = "D1批量查成员个人资料列表(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public BatchQueryMemberProfileListByIdsComRespDto batchQueryMemberProfileListByIdsCom(BatchQueryMemberProfileListByIdsComReqDto reqDto) {


        List<OriginalRoleMember> listOriginalRoleMember_1 = new ArrayList<>();
        List<OriginalRoleMemberInfo> listOriginalRoleMemberInfo_1 = new ArrayList<>();
        List<Userinfo> listUserinfo_1 = new ArrayList<>();
        List<Users> listUsers_1 = new ArrayList<>();
//virtualUsage 1-2-09批量查询身份人员列表	  49577
        List<OriginalRoleMember> listOriginalRoleMember = new ArrayList<>();
        BatchQueryBeginMemberListReq batchQueryBeginMemberListReq = new BatchQueryBeginMemberListReq();
        batchQueryBeginMemberListReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1159414_1_49577
        batchQueryBeginMemberListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1159417_1_49577
        if (reqDto != null) {
            batchQueryBeginMemberListReq.setBeginMemberList(reqDto.getBeginMemberList());//list-field-assign//sourceId:1159410_1_49577
        }

        /*1-2-09批量查询身份人员列表	[1181]   */
        Assert.isNull(batchQueryBeginMemberListReq.getSubjectLifeCycle(), "D1批量查成员个人资料列表(公共)-1-2-09批量查询身份人员列表	-主体生命周期不能为空", false);
        Assert.isNull(batchQueryBeginMemberListReq.getSpaceId(), "D1批量查成员个人资料列表(公共)-1-2-09批量查询身份人员列表	-创建于空间ID不能为空", false);
        listOriginalRoleMember = mOriginalRoleMemberService.batchQueryBeginMemberList(batchQueryBeginMemberListReq)/*vcase invoke 本地 method 方法调用;*/;


        listOriginalRoleMember_1 = listOriginalRoleMember;
//virtualUsage 1-2-10批量查身份人员编号列表  49618
        List<OriginalRoleMemberInfo> listOriginalRoleMemberInfo = new ArrayList<>();
        if (listOriginalRoleMember != null && !CollectionUtil.isEmpty(listOriginalRoleMember) && listOriginalRoleMember.size() > 0) {
            BatchQueryBeginMembInfoListReq batchQueryBeginMembInfoListReq = new BatchQueryBeginMembInfoListReq();
            if (listOriginalRoleMember != null && !CollectionUtil.isEmpty(listOriginalRoleMember) && listOriginalRoleMember != null && !CollectionUtil.isEmpty(listOriginalRoleMember)) {
                batchQueryBeginMembInfoListReq.setBeginMembInfoList(listOriginalRoleMember.stream().map(item -> item.getOriginalRoleMemberId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1161963_1_49618
            }

            /*1-2-10批量查身份人员编号列表[1014]   */

            listOriginalRoleMemberInfo = mOriginalRoleMemberInfoService.batchQueryBeginMembInfoList(batchQueryBeginMembInfoListReq)/*vcase invoke 本地 method 方法调用;*/;


            listOriginalRoleMemberInfo_1 = listOriginalRoleMemberInfo;
        }
//virtualUsage 1-2-02批量查询个人资料列表  49578
        List<Userinfo> listUserinfo = new ArrayList<>();
        if (listOriginalRoleMember != null && !CollectionUtil.isEmpty(listOriginalRoleMember) && listOriginalRoleMember.size() > 0) {
            BatchQueryUserinfoListReq batchQueryUserinfoListReq = new BatchQueryUserinfoListReq();
            if (listOriginalRoleMember != null && !CollectionUtil.isEmpty(listOriginalRoleMember) && listOriginalRoleMember != null && !CollectionUtil.isEmpty(listOriginalRoleMember)) {
                batchQueryUserinfoListReq.setUserList(listOriginalRoleMember.stream().map(item -> item.getUserId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1159418_1_49578
            }

            /*1-2-02批量查询个人资料列表[52]   */

            listUserinfo = mUserinfoService.batchQueryUserinfoList(batchQueryUserinfoListReq)/*vcase invoke 本地 method 方法调用;*/;


            listUserinfo_1 = listUserinfo;
        }
//virtualUsage 1-2-01批量查个人账号  49579
        List<Users> listUsers = new ArrayList<>();
        if (listOriginalRoleMember != null && !CollectionUtil.isEmpty(listOriginalRoleMember) && listOriginalRoleMember.size() > 0) {
            BatchQueryUserReq batchQueryUserReq = new BatchQueryUserReq();
            if (listOriginalRoleMember != null && !CollectionUtil.isEmpty(listOriginalRoleMember) && listOriginalRoleMember != null && !CollectionUtil.isEmpty(listOriginalRoleMember)) {
                batchQueryUserReq.setUsersList(listOriginalRoleMember.stream().map(item -> item.getUserId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1159423_1_49579
            }

            /*1-2-01批量查个人账号[1293]   */

            listUsers = mUsersService.batchQueryUser(batchQueryUserReq)/*vcase invoke 本地 method 方法调用;*/;


            listUsers_1 = listUsers;
        }
        BatchQueryMemberProfileListByIdsComRespDto retData = new BatchQueryMemberProfileListByIdsComRespDto();
        //数据集融合  MoreListToOneSource
        if (listOriginalRoleMember_1 != null && !CollectionUtil.isEmpty(listOriginalRoleMember_1) && !CollectionUtil.isEmpty(listOriginalRoleMember_1)) {
            for (OriginalRoleMember originalRoleMember : listOriginalRoleMember_1) {
                BeginMemberDto retElm = new BeginMemberDto();
                retElm.setOriginalRoleMemberId(originalRoleMember.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:241500_2
                retElm.setUserId(originalRoleMember.getUserId());//SimpleFieldAssign//sourceId:241501_2
                retData.getBeginMemberList().add(retElm);
                if (listOriginalRoleMemberInfo_1 != null && !CollectionUtil.isEmpty(listOriginalRoleMemberInfo_1)) {
                    for (OriginalRoleMemberInfo originalRoleMemberInfo : listOriginalRoleMemberInfo_1) {
                        if (originalRoleMemberInfo.getOriginalRoleMemberId().equals(originalRoleMember.getOriginalRoleMemberId())) {
                            retElm.setRoleMemberCode(originalRoleMemberInfo.getRoleMemberCode());//SimpleFieldAssign//sourceId:241799_2
                        }
                    }
                }

                if (listUserinfo_1 != null && !CollectionUtil.isEmpty(listUserinfo_1)) {
                    for (Userinfo userinfo : listUserinfo_1) {
                        if (userinfo.getUserId().equals(originalRoleMember.getUserId())) {
                            retElm.setUserFace(userinfo.getUserFace());//SimpleFieldAssign//sourceId:241504_2
                            retElm.setIdCardName(userinfo.getIdCardName());//SimpleFieldAssign//sourceId:241503_2
                            retElm.setNickName(userinfo.getNickName());//SimpleFieldAssign//sourceId:259115_2
                            retElm.setFirstLetter(userinfo.getFirstLetter());//SimpleFieldAssign//sourceId:319271_2
                        }
                    }
                }

                if (listUsers_1 != null && !CollectionUtil.isEmpty(listUsers_1)) {
                    for (Users users : listUsers_1) {
                        if (users.getUserId().equals(originalRoleMember.getUserId())) {
                            retElm.setPhone(users.getPhone());//SimpleFieldAssign//sourceId:241523_2
                        }
                    }
                }

            }
        }//sourceId:1159422_1


        return retData;
    }

    /**
     * D1查角色人员信息(公共)[7913]
     * gen by moon at 11/12/2023, 3:56:27 AM
     */
    @Trace(operationName = "D1查角色人员信息(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryRoleRelInfoDetailComRespDto queryRoleRelInfoDetailCom(QueryRoleRelInfoDetailComReqDto reqDto) {


        RoleMember roleMember_1 = null;
//步骤0: 1-2-13查询角色人员详情 - queryRoleRelDetail
        RoleMember roleMember = null;
        QueryRoleRelDetailReq queryRoleRelDetailReq = new QueryRoleRelDetailReq();
        queryRoleRelDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1298961_1
        if (reqDto != null) {
            queryRoleRelDetailReq.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1298958_1
            queryRoleRelDetailReq.setRoleCode(reqDto.getRoleCode());//SimpleFieldAssign//sourceId:1298959_1
            queryRoleRelDetailReq.setRelationshipValid(reqDto.getRelationshipValid());//SimpleFieldAssign//sourceId:1298960_1
        }

        /*1-2-13查询角色人员详情[335]   */
        Assert.isNull(queryRoleRelDetailReq.getSubjectLifeCycle(), "D1查角色人员信息(公共)-1-2-13查询角色人员详情-主体生命周期不能为空", false);
        roleMember = mRoleMemberService.queryRoleRelDetail(queryRoleRelDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        roleMember_1 = roleMember;

        QueryRoleRelInfoDetailComRespDto retData = new QueryRoleRelInfoDetailComRespDto();
        if (roleMember_1 != null) {
            retData.setRoleMemberId(roleMember_1.getRoleMemberId());//SimpleFieldAssign//sourceId:1298966_1
        }


        return retData;
    }

    /**
     * D1查询个人手机号等列表(公共)[7973]
     * gen by moon at 11/18/2023, 1:24:43 PM
     */
    @Trace(operationName = "D1查询个人手机号等列表(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryPersonPhoneNumEtcListComRespDto queryPersonPhoneNumEtcListCom(QueryPersonPhoneNumEtcListComReqDto reqDto) {


        List<Users> listUsers_1 = new ArrayList<>();
        List<Userinfo> listUserinfo_1 = new ArrayList<>();
//步骤0: 1-2-01查询个人账号列表 - queryUserList
        List<Users> listUsers = new ArrayList<>();
        QueryUserListReq queryUserListReq = new QueryUserListReq();
        queryUserListReq.setIsInvalid("FALSE");//sourceId:1328075_1
        if (reqDto != null) {
            queryUserListReq.setUserId(reqDto.getUserId());//SimpleFieldAssign//sourceId:1328074_1
            queryUserListReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1328076_1
        }

        /*1-2-01查询个人账号列表[48]   */
        Assert.isNull(queryUserListReq.getIsInvalid(), "D1查询个人手机号等列表(公共)-1-2-01查询个人账号列表-是否失效不能为空", false);
        Assert.isNull(queryUserListReq.getSpaceId(), "D1查询个人手机号等列表(公共)-1-2-01查询个人账号列表-创建于空间ID不能为空", false);
        listUsers = mUsersService.queryUserList(queryUserListReq)/*vcase invoke 本地 method 方法调用;*/;


        listUsers_1 = listUsers;

//步骤1: 1-2-02批量查询个人资料列表 - batchQueryUserinfoList
        List<Userinfo> listUserinfo = new ArrayList<>();
        if (listUsers != null && !CollectionUtil.isEmpty(listUsers) && listUsers.size() > 0) {
            BatchQueryUserinfoListReq batchQueryUserinfoListReq = new BatchQueryUserinfoListReq();
            if (listUsers != null && !CollectionUtil.isEmpty(listUsers) && listUsers != null && !CollectionUtil.isEmpty(listUsers)) {
                batchQueryUserinfoListReq.setUserList(listUsers.stream().map(item -> item.getUserId())
                        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1328080_1
            }
            if (reqDto != null) {
                batchQueryUserinfoListReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1328082_1
            }

            /*1-2-02批量查询个人资料列表[52]   */
            Assert.isNull(batchQueryUserinfoListReq.getSpaceId(), "D1查询个人手机号等列表(公共)-1-2-02批量查询个人资料列表-创建于空间ID不能为空", false);
            listUserinfo = mUserinfoService.batchQueryUserinfoList(batchQueryUserinfoListReq)/*vcase invoke 本地 method 方法调用;*/;


            listUserinfo_1 = listUserinfo;
        }

        QueryPersonPhoneNumEtcListComRespDto retData = new QueryPersonPhoneNumEtcListComRespDto();
        //数据集融合  MoreListToOneSource
        if (listUsers_1 != null && !CollectionUtil.isEmpty(listUsers_1) && !CollectionUtil.isEmpty(listUsers_1)) {
            for (Users users : listUsers_1) {
                UsersDto retElm = new UsersDto();
                retElm.setUserId(users.getUserId());//SimpleFieldAssign//sourceId:270626_2
                retElm.setPhone(users.getPhone());//SimpleFieldAssign//sourceId:270627_2
                retData.getUsersList().add(retElm);
                if (listUserinfo_1 != null && !CollectionUtil.isEmpty(listUserinfo_1)) {
                    for (Userinfo userinfo : listUserinfo_1) {
                        if (userinfo.getUserId().equals(users.getUserId())) {
                            retElm.setIdCardName(userinfo.getIdCardName());//SimpleFieldAssign//sourceId:270628_2
                        }
                    }
                }

            }
        }//sourceId:1328099_1


        return retData;
    }

    /**
     * D1查询身份人员列表(公共)[7971]
     * gen by moon at 11/18/2023, 6:32:33 PM
     */
    @Trace(operationName = "D1查询身份人员列表(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryBeginMemberListComRespDto queryBeginMemberListCom(QueryBeginMemberListComReqDto reqDto) {


        List<OriginalRoleMember> listOriginalRoleMember_1 = new ArrayList<>();
//步骤0: 1-2-09查询身份人员列表 - queryBeginMemberList
        List<OriginalRoleMember> listOriginalRoleMember = new ArrayList<>();
        QueryBeginMemberListReq queryBeginMemberListReq = new QueryBeginMemberListReq();
        if (reqDto != null) {
            queryBeginMemberListReq.setRoleCode(reqDto.getRoleCode());//SimpleFieldAssign//sourceId:1326058_1
            queryBeginMemberListReq.setIsTransaction(reqDto.getIsTransaction());//SimpleFieldAssign//sourceId:1326059_1
            queryBeginMemberListReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1326060_1
            queryBeginMemberListReq.setIsInvalid(reqDto.getIsInvalid());//SimpleFieldAssign//sourceId:1326061_1
            queryBeginMemberListReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1326062_1
        }

        /*1-2-09查询身份人员列表[80]   */
        Assert.isNull(queryBeginMemberListReq.getSpaceId(), "D1查询身份人员列表(公共)-1-2-09查询身份人员列表-创建于空间ID不能为空", false);
        listOriginalRoleMember = mOriginalRoleMemberService.queryBeginMemberList(queryBeginMemberListReq)/*vcase invoke 本地 method 方法调用;*/;


        listOriginalRoleMember_1 = listOriginalRoleMember;

        QueryBeginMemberListComRespDto retData = new QueryBeginMemberListComRespDto();
        retData.setBeginMemberList(listOriginalRoleMember_1.stream().map(item -> BeanUtil.toBean(item, BeginMemberDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1326068_1


        return retData;
    }

    /**
     * D1查询身份人员资料列表(公共)[7981]
     * gen by moon at 11/19/2023, 1:59:51 PM
     */
    @Trace(operationName = "D1查询身份人员资料列表(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryBeginMembInfoListComRespDto queryBeginMembInfoListCom(QueryBeginMembInfoListComReqDto reqDto) {


        List<OriginalRoleMemberInfo> listOriginalRoleMemberInfo_1 = new ArrayList<>();
//步骤0: 1-2-10查询身份人员资料列表 - queryBeginMembInfoList
        List<OriginalRoleMemberInfo> listOriginalRoleMemberInfo = new ArrayList<>();
        QueryBeginMembInfoListReq queryBeginMembInfoListReq = new QueryBeginMembInfoListReq();
        if (reqDto != null) {
            queryBeginMembInfoListReq.setRoleMemberCode(reqDto.getRoleMemberCode());//SimpleFieldAssign//sourceId:1331758_1
            queryBeginMembInfoListReq.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1331760_1
        }

        /*1-2-10查询身份人员资料列表[4016]   */

        listOriginalRoleMemberInfo = mOriginalRoleMemberInfoService.queryBeginMembInfoList(queryBeginMembInfoListReq)/*vcase invoke 本地 method 方法调用;*/;


        listOriginalRoleMemberInfo_1 = listOriginalRoleMemberInfo;

        QueryBeginMembInfoListComRespDto retData = new QueryBeginMembInfoListComRespDto();
        retData.setBeginMembInfoList(listOriginalRoleMemberInfo_1.stream().map(item -> BeanUtil.toBean(item, BeginMembInfoDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1331763_1


        return retData;
    }

    /**
     * D1执行循环部门群成员通道关系处理(公共)[8198]
     * gen by moon at 1/21/2024, 7:51:08 PM
     */
    @Trace(operationName = "D1执行循环部门群成员通道关系处理(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementLoopDeptGroupMemberChannelExitProcessComRespDto implementLoopDeptGroupMemberChannelExitProcessCom(ImplementLoopDeptGroupMemberChannelExitProcessComReqDto reqDto) {


        if ((reqDto != null && reqDto.getNewInductionRecordList() != null && reqDto.getNewInductionRecordList().size() > 0)) {
            //if(D1执行循环部门群成员通道关系处理(公共).本次新增就职记录列表数据集条数 大于 0)  57260

//ModelCode: receptionService
            QueryReceiveFieldDetailRespDto receptionServiceRes = null;
            QueryReceiveFieldDetailReqDto receptionServiceReq = new QueryReceiveFieldDetailReqDto();
            if (reqDto != null && reqDto.getNewInductionRecordList() != null && !CollectionUtil.isEmpty(reqDto.getNewInductionRecordList())) {
                receptionServiceReq.setOrgInductionRecordList(reqDto.getNewInductionRecordList().stream().map(item -> BeanUtil.toBean(item, OrgInductionRecordDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1438318_1_57270
            }

            /*M1接收就职记录数据集入参[3715]  用于特殊方法接收上游入参。 */

            receptionServiceRes = nbMember.queryReceiveFieldDetail(receptionServiceReq);


//ModelCode: circulationCollections
            for (OrgInductionRecordDto circulationCollectionsRes : receptionServiceRes.getOrgInductionRecordList()) {

                Userinfo userinfo = null;
                QueryUserinfoDetailReq queryUserinfoDetailReq = new QueryUserinfoDetailReq();
                if (circulationCollectionsRes != null) {
                    queryUserinfoDetailReq.setUserId(circulationCollectionsRes.getUserId());//SimpleFieldAssign//sourceId:1494017_1_59952
                }

                /*1-2-02查询个人资料详情[155]   */
                Assert.isNull(queryUserinfoDetailReq.getUserId(), "D1执行循环部门群成员通道关系处理(公共)-1-2-02查询个人资料详情-账号不能为空", false);
                userinfo = mUserinfoService.queryUserinfoDetail(queryUserinfoDetailReq)/*vcase invoke 本地 method 方法调用;*/;


                ImplementMemberChannelAddProcessComRespDto implementMemberChannelAddProcessComRespDto = null;
                if (userinfo != null) {
                    ImplementMemberChannelAddProcessComReqDto implementMemberChannelAddProcessComReqDto = new ImplementMemberChannelAddProcessComReqDto();
                    implementMemberChannelAddProcessComReqDto.setChannelTypeCode("DEPT_GROUP");//sourceId:1438070_1_57269
                    implementMemberChannelAddProcessComReqDto.setBorcScene("TOB_SCENE");//sourceId:1438067_1_57269
                    if (circulationCollectionsRes != null) {
                        implementMemberChannelAddProcessComReqDto.setOriginalRoleMemberId(circulationCollectionsRes.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1438065_1_57269
                        implementMemberChannelAddProcessComReqDto.setUserId(circulationCollectionsRes.getUserId());//SimpleFieldAssign//sourceId:1438066_1_57269
                        implementMemberChannelAddProcessComReqDto.setEntityId(circulationCollectionsRes.getEntityId());//SimpleFieldAssign//sourceId:1438069_1_57269
                        implementMemberChannelAddProcessComReqDto.setSenderOriginalRoleMemberId(circulationCollectionsRes.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1494018_1_57269
                        implementMemberChannelAddProcessComReqDto.setSenderUserId(circulationCollectionsRes.getUserId());//SimpleFieldAssign//sourceId:1494019_1_57269
                    }
                    if (userinfo != null) {
                        implementMemberChannelAddProcessComReqDto.setNameOfSender(userinfo.getIdCardName());//SimpleFieldAssign//sourceId:1494021_1_57269
                        implementMemberChannelAddProcessComReqDto.setSenderProfilePictureAddress(userinfo.getUserFace());//SimpleFieldAssign//sourceId:1494020_1_57269
                    }

                    /*D2执行成员通道关系新增处理(公共)[8190]   */
                    Assert.isNull(implementMemberChannelAddProcessComReqDto.getOriginalRoleMemberId(), "D1执行循环部门群成员通道关系处理(公共)-D2执行成员通道关系新增处理(公共)-身份人员ID不能为空", false);
                    Assert.isNull(implementMemberChannelAddProcessComReqDto.getUserId(), "D1执行循环部门群成员通道关系处理(公共)-D2执行成员通道关系新增处理(公共)-个人账号ID不能为空", false);
                    Assert.isNull(implementMemberChannelAddProcessComReqDto.getEntityId(), "D1执行循环部门群成员通道关系处理(公共)-D2执行成员通道关系新增处理(公共)-归属主体内容ID不能为空", false);
                    Assert.isNull(implementMemberChannelAddProcessComReqDto.getSenderOriginalRoleMemberId(), "D1执行循环部门群成员通道关系处理(公共)-D2执行成员通道关系新增处理(公共)-发送方身份人员ID不能为空", false);
                    Assert.isNull(implementMemberChannelAddProcessComReqDto.getSenderUserId(), "D1执行循环部门群成员通道关系处理(公共)-D2执行成员通道关系新增处理(公共)-发送方账号ID不能为空", false);
                    Assert.isNull(implementMemberChannelAddProcessComReqDto.getNameOfSender(), "D1执行循环部门群成员通道关系处理(公共)-D2执行成员通道关系新增处理(公共)-发送方姓名不能为空", false);
                    Assert.isNull(implementMemberChannelAddProcessComReqDto.getSenderProfilePictureAddress(), "D1执行循环部门群成员通道关系处理(公共)-D2执行成员通道关系新增处理(公共)-发送方头像地址不能为空", false);
                    Assert.isNull(implementMemberChannelAddProcessComReqDto.getChannelTypeCode(), "D1执行循环部门群成员通道关系处理(公共)-D2执行成员通道关系新增处理(公共)-通道类型编码不能为空", false);
                    Assert.isNull(implementMemberChannelAddProcessComReqDto.getBorcScene(), "D1执行循环部门群成员通道关系处理(公共)-D2执行成员通道关系新增处理(公共)-toB或toC场景不能为空", false);
                    implementMemberChannelAddProcessComRespDto = fwCompMessageClient.implementMemberChannelAddProcessCom(implementMemberChannelAddProcessComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                }
//ModelCode: circulationEnd
            }

        }
        if ((reqDto != null && reqDto.getOldInductionRecordList() != null && reqDto.getOldInductionRecordList().size() > 0)) {
            //if(D1执行循环部门群成员通道关系处理(公共).本次存档就职记录列表数据集条数 大于 0)  57272

//ModelCode: receptionService
            QueryReceiveFieldDetailRespDto receptionServiceRes_2 = null;
            QueryReceiveFieldDetailReqDto receptionServiceReq_1 = new QueryReceiveFieldDetailReqDto();
            if (reqDto != null && reqDto.getOldInductionRecordList() != null && !CollectionUtil.isEmpty(reqDto.getOldInductionRecordList())) {
                receptionServiceReq_1.setOrgInductionRecordList(reqDto.getOldInductionRecordList().stream().map(item -> BeanUtil.toBean(item, OrgInductionRecordDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1438318_1_57273
            }

            /*M1接收就职记录数据集入参[3715]  用于特殊方法接收上游入参。 */

            receptionServiceRes_2 = nbMember.queryReceiveFieldDetail(receptionServiceReq_1);


//ModelCode: circulationCollections
            for (OrgInductionRecordDto circulationCollectionsRes_2 : receptionServiceRes_2.getOrgInductionRecordList()) {

                ImplementMemberChannelExitProcessComRespDto implementMemberChannelExitProcessComRespDto = null;
                ImplementMemberChannelExitProcessComReqDto implementMemberChannelExitProcessComReqDto = new ImplementMemberChannelExitProcessComReqDto();
                implementMemberChannelExitProcessComReqDto.setChannelTypeCode("DEPT_GROUP");//sourceId:1438075_1_57276
                implementMemberChannelExitProcessComReqDto.setIsSaveData("TRUE");//sourceId:1438080_1_57276
                if (circulationCollectionsRes_2 != null) {
                    implementMemberChannelExitProcessComReqDto.setOriginalRoleMemberId(circulationCollectionsRes_2.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1438076_1_57276
                    implementMemberChannelExitProcessComReqDto.setUserId(circulationCollectionsRes_2.getUserId());//SimpleFieldAssign//sourceId:1438077_1_57276
                    implementMemberChannelExitProcessComReqDto.setEntityId(circulationCollectionsRes_2.getEntityId());//SimpleFieldAssign//sourceId:1438074_1_57276
                }
                if (reqDto != null) {
                    implementMemberChannelExitProcessComReqDto.setMessageLocationCode(reqDto.getMessageLocationCode());//SimpleFieldAssign//sourceId:1438079_1_57276
                    implementMemberChannelExitProcessComReqDto.setBorcScene(reqDto.getBorcScene());//SimpleFieldAssign//sourceId:1438078_1_57276
                }

                /*D2执行成员通道关系退出处理(公共)[8191]   */
                Assert.isNull(implementMemberChannelExitProcessComReqDto.getOriginalRoleMemberId(), "D1执行循环部门群成员通道关系处理(公共)-D2执行成员通道关系退出处理(公共)-身份人员ID不能为空", false);
                Assert.isNull(implementMemberChannelExitProcessComReqDto.getUserId(), "D1执行循环部门群成员通道关系处理(公共)-D2执行成员通道关系退出处理(公共)-个人账号ID不能为空", false);
                Assert.isNull(implementMemberChannelExitProcessComReqDto.getEntityId(), "D1执行循环部门群成员通道关系处理(公共)-D2执行成员通道关系退出处理(公共)-归属主体内容ID不能为空", false);
                Assert.isNull(implementMemberChannelExitProcessComReqDto.getChannelTypeCode(), "D1执行循环部门群成员通道关系处理(公共)-D2执行成员通道关系退出处理(公共)-通道类型编码不能为空", false);
                Assert.isNull(implementMemberChannelExitProcessComReqDto.getIsSaveData(), "D1执行循环部门群成员通道关系处理(公共)-D2执行成员通道关系退出处理(公共)-是否退出保留不能为空", false);
                Assert.isNull(implementMemberChannelExitProcessComReqDto.getMessageLocationCode(), "D1执行循环部门群成员通道关系处理(公共)-D2执行成员通道关系退出处理(公共)-消息位置标识不能为空", false);
                Assert.isNull(implementMemberChannelExitProcessComReqDto.getBorcScene(), "D1执行循环部门群成员通道关系处理(公共)-D2执行成员通道关系退出处理(公共)-toB或toC场景不能为空", false);
                implementMemberChannelExitProcessComRespDto = fwCompMessageClient.implementMemberChannelExitProcessCom(implementMemberChannelExitProcessComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


//ModelCode: circulationEnd
            }

        }
        ImplementLoopDeptGroupMemberChannelExitProcessComRespDto retData = new ImplementLoopDeptGroupMemberChannelExitProcessComRespDto();


        return retData;
    }

    /**
     * D1执行组织群成员通道关系处理(公共)[8199]
     * gen by moon at 1/21/2024, 7:51:11 PM
     */
    @Trace(operationName = "D1执行组织群成员通道关系处理(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementOrgGroupMemberChannelExitProcessComRespDto implementOrgGroupMemberChannelExitProcessCom(ImplementOrgGroupMemberChannelExitProcessComReqDto reqDto) {


        if ((reqDto != null && reqDto.getNewInductionRecordList() != null && reqDto.getNewInductionRecordList().size() > 0)) {
            //if(D1执行组织群成员通道关系处理(公共).本次新增就职记录列表数据集条数 大于 0)  57281

//ModelCode: receptionService
            QueryReceiveFieldDetailRespDto receptionServiceRes = null;
            QueryReceiveFieldDetailReqDto receptionServiceReq = new QueryReceiveFieldDetailReqDto();
            if (reqDto != null && reqDto.getNewInductionRecordList() != null && !CollectionUtil.isEmpty(reqDto.getNewInductionRecordList())) {
                receptionServiceReq.setOrgInductionRecordList(reqDto.getNewInductionRecordList().stream().map(item -> BeanUtil.toBean(item, OrgInductionRecordDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1438896_1_57284
            }

            /*M1接收就职记录数据集入参[3715]  用于特殊方法接收上游入参。 */

            receptionServiceRes = nbMember.queryReceiveFieldDetail(receptionServiceReq);


            Organization organization = null;
            QueryOrgDetailReq queryOrgDetailReq = new QueryOrgDetailReq();
            queryOrgDetailReq.setIsHighOrg("TRUE");//sourceId:1443314_1_57420
            queryOrgDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1443315_1_57420
            queryOrgDetailReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1443316_1_57420

            /*1-3-12查当前空间最高组织ID（用于查最高组织下所有的就职记录入参）[201]   */
            Assert.isNull(queryOrgDetailReq.getIsHighOrg(), "D1执行组织群成员通道关系处理(公共)-1-3-12查当前空间最高组织ID（用于查最高组织下所有的就职记录入参）-是否最高组织不能为空", false);
            Assert.isNull(queryOrgDetailReq.getSubjectLifeCycle(), "D1执行组织群成员通道关系处理(公共)-1-3-12查当前空间最高组织ID（用于查最高组织下所有的就职记录入参）-主体生命周期不能为空", false);
            Assert.isNull(queryOrgDetailReq.getSpaceId(), "D1执行组织群成员通道关系处理(公共)-1-3-12查当前空间最高组织ID（用于查最高组织下所有的就职记录入参）-创建于空间ID不能为空", false);
            organization = mOrganizationService.queryOrgDetail(queryOrgDetailReq)/*vcase invoke 本地 method 方法调用;*/;


//ModelCode: circulationCollections
            for (OrgInductionRecordDto circulationCollectionsRes : receptionServiceRes.getOrgInductionRecordList()) {

                Userinfo userinfo = null;
                QueryUserinfoDetailReq queryUserinfoDetailReq = new QueryUserinfoDetailReq();
                if (circulationCollectionsRes != null) {
                    queryUserinfoDetailReq.setUserId(circulationCollectionsRes.getUserId());//SimpleFieldAssign//sourceId:1493958_1_59950
                }

                /*1-2-02查询个人资料详情[155]   */
                Assert.isNull(queryUserinfoDetailReq.getUserId(), "D1执行组织群成员通道关系处理(公共)-1-2-02查询个人资料详情-账号不能为空", false);
                userinfo = mUserinfoService.queryUserinfoDetail(queryUserinfoDetailReq)/*vcase invoke 本地 method 方法调用;*/;


                ImplementMemberChannelAddProcessComRespDto implementMemberChannelAddProcessComRespDto = null;
                if (organization != null && userinfo != null) {
                    ImplementMemberChannelAddProcessComReqDto implementMemberChannelAddProcessComReqDto = new ImplementMemberChannelAddProcessComReqDto();
                    implementMemberChannelAddProcessComReqDto.setChannelTypeCode("ORG_GROUP");//sourceId:1438908_1_57287
                    implementMemberChannelAddProcessComReqDto.setBorcScene("TOB_SCENE");//sourceId:1438905_1_57287
                    if (circulationCollectionsRes != null) {
                        implementMemberChannelAddProcessComReqDto.setOriginalRoleMemberId(circulationCollectionsRes.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1438903_1_57287
                        implementMemberChannelAddProcessComReqDto.setUserId(circulationCollectionsRes.getUserId());//SimpleFieldAssign//sourceId:1438904_1_57287
                        implementMemberChannelAddProcessComReqDto.setSenderOriginalRoleMemberId(circulationCollectionsRes.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1493967_1_57287
                        implementMemberChannelAddProcessComReqDto.setSenderUserId(circulationCollectionsRes.getUserId());//SimpleFieldAssign//sourceId:1493968_1_57287
                    }
                    if (organization != null) {
                        implementMemberChannelAddProcessComReqDto.setEntityId(organization.getOrganizationId());//SimpleFieldAssign//sourceId:1438907_1_57287
                    }
                    if (userinfo != null) {
                        implementMemberChannelAddProcessComReqDto.setSenderProfilePictureAddress(userinfo.getUserFace());//SimpleFieldAssign//sourceId:1493969_1_57287
                        implementMemberChannelAddProcessComReqDto.setNameOfSender(userinfo.getIdCardName());//SimpleFieldAssign//sourceId:1493970_1_57287
                    }

                    /*D2执行成员通道关系新增处理(公共)[8190]   */
                    Assert.isNull(implementMemberChannelAddProcessComReqDto.getOriginalRoleMemberId(), "D1执行组织群成员通道关系处理(公共)-D2执行成员通道关系新增处理(公共)-身份人员ID不能为空", false);
                    Assert.isNull(implementMemberChannelAddProcessComReqDto.getUserId(), "D1执行组织群成员通道关系处理(公共)-D2执行成员通道关系新增处理(公共)-个人账号ID不能为空", false);
                    Assert.isNull(implementMemberChannelAddProcessComReqDto.getEntityId(), "D1执行组织群成员通道关系处理(公共)-D2执行成员通道关系新增处理(公共)-归属主体内容ID不能为空", false);
                    Assert.isNull(implementMemberChannelAddProcessComReqDto.getSenderOriginalRoleMemberId(), "D1执行组织群成员通道关系处理(公共)-D2执行成员通道关系新增处理(公共)-发送方身份人员ID不能为空", false);
                    Assert.isNull(implementMemberChannelAddProcessComReqDto.getSenderUserId(), "D1执行组织群成员通道关系处理(公共)-D2执行成员通道关系新增处理(公共)-发送方账号ID不能为空", false);
                    Assert.isNull(implementMemberChannelAddProcessComReqDto.getSenderProfilePictureAddress(), "D1执行组织群成员通道关系处理(公共)-D2执行成员通道关系新增处理(公共)-发送方头像地址不能为空", false);
                    Assert.isNull(implementMemberChannelAddProcessComReqDto.getNameOfSender(), "D1执行组织群成员通道关系处理(公共)-D2执行成员通道关系新增处理(公共)-发送方姓名不能为空", false);
                    Assert.isNull(implementMemberChannelAddProcessComReqDto.getChannelTypeCode(), "D1执行组织群成员通道关系处理(公共)-D2执行成员通道关系新增处理(公共)-通道类型编码不能为空", false);
                    Assert.isNull(implementMemberChannelAddProcessComReqDto.getBorcScene(), "D1执行组织群成员通道关系处理(公共)-D2执行成员通道关系新增处理(公共)-toB或toC场景不能为空", false);
                    implementMemberChannelAddProcessComRespDto = fwCompMessageClient.implementMemberChannelAddProcessCom(implementMemberChannelAddProcessComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                }
//ModelCode: circulationEnd
            }

        }
        if ((reqDto != null && reqDto.getOldInductionRecordList() != null && reqDto.getOldInductionRecordList().size() > 0)) {
            //if(D1执行组织群成员通道关系处理(公共).本次存档就职记录列表数据集条数 大于 0)  57283

            ImplementManyFieldsDataSetDuplicateRemovalComRespDto implementManyFieldsDataSetDuplicateRemovalComRespDto = null;
            ImplementManyFieldsDataSetDuplicateRemovalComReqDto implementManyFieldsDataSetDuplicateRemovalComReqDto = new ImplementManyFieldsDataSetDuplicateRemovalComReqDto();
            if (reqDto != null && reqDto.getOldInductionRecordList() != null && !CollectionUtil.isEmpty(reqDto.getOldInductionRecordList())) {
                implementManyFieldsDataSetDuplicateRemovalComReqDto.setDataSetDuplicateRemovalList(//objList-to-objLists
                        reqDto.getOldInductionRecordList().stream().map(item -> {
                            DataSetDuplicateRemovalDto elm = new DataSetDuplicateRemovalDto();
                            if (item != null) {
                                elm.setCommPrimaryKey(item.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:288064_2_57290
                                elm.setCustomField1(item.getUserId());//SimpleFieldAssign//sourceId:288065_2_57290
                            }
                            return elm;
                        }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1438673_1_57290
            }

            /*D2执行多字段数据集记录去重(公共)[7323]   */

            implementManyFieldsDataSetDuplicateRemovalComRespDto = interfaceModeService.implementManyFieldsDataSetDuplicateRemovalCom(implementManyFieldsDataSetDuplicateRemovalComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            Organization organization_2 = null;
            QueryOrgDetailReq queryOrgDetailReq_1 = new QueryOrgDetailReq();
            queryOrgDetailReq_1.setIsHighOrg("TRUE");//sourceId:1443314_1_57382
            queryOrgDetailReq_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1443315_1_57382
            queryOrgDetailReq_1.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1443316_1_57382

            /*1-3-12查当前空间最高组织ID（用于查最高组织下所有的就职记录入参）[201]   */
            Assert.isNull(queryOrgDetailReq_1.getIsHighOrg(), "D1执行组织群成员通道关系处理(公共)-1-3-12查当前空间最高组织ID（用于查最高组织下所有的就职记录入参）-是否最高组织不能为空", false);
            Assert.isNull(queryOrgDetailReq_1.getSubjectLifeCycle(), "D1执行组织群成员通道关系处理(公共)-1-3-12查当前空间最高组织ID（用于查最高组织下所有的就职记录入参）-主体生命周期不能为空", false);
            Assert.isNull(queryOrgDetailReq_1.getSpaceId(), "D1执行组织群成员通道关系处理(公共)-1-3-12查当前空间最高组织ID（用于查最高组织下所有的就职记录入参）-创建于空间ID不能为空", false);
            organization_2 = mOrganizationService.queryOrgDetail(queryOrgDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;


            List<InductionRecord> listInductionRecord = new ArrayList<>();
            if (organization_2 != null) {
                QueryInductionRecordListReq queryInductionRecordListReq = new QueryInductionRecordListReq();
                queryInductionRecordListReq.setIsTransaction("FALSE");//sourceId:1438659_1_57288
                queryInductionRecordListReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1438660_1_57288
                queryInductionRecordListReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1438661_1_57288
                if (organization_2 != null) {
                    queryInductionRecordListReq.setOrganizationId(organization_2.getOrganizationId());//SimpleFieldAssign//sourceId:1438658_1_57288
                }

                /*1-3-13查组织下就职记录列表[166]   */
                Assert.isNull(queryInductionRecordListReq.getOrganizationId(), "D1执行组织群成员通道关系处理(公共)-1-3-13查组织下就职记录列表-组织ID不能为空", false);
                Assert.isNull(queryInductionRecordListReq.getIsTransaction(), "D1执行组织群成员通道关系处理(公共)-1-3-13查组织下就职记录列表-是否异动不能为空", false);
                Assert.isNull(queryInductionRecordListReq.getSubjectLifeCycle(), "D1执行组织群成员通道关系处理(公共)-1-3-13查组织下就职记录列表-主体生命周期不能为空", false);
                Assert.isNull(queryInductionRecordListReq.getSpaceId(), "D1执行组织群成员通道关系处理(公共)-1-3-13查组织下就职记录列表-创建于空间ID不能为空", false);
                listInductionRecord = mInductionRecordService.queryInductionRecordList(queryInductionRecordListReq)/*vcase invoke 本地 method 方法调用;*/;


            }
            ImplementManyFieldsDataSetDuplicateRemovalComRespDto implementManyFieldsDataSetDuplicateRemovalComRespDto_2 = null;
            if (listInductionRecord != null && !CollectionUtil.isEmpty(listInductionRecord) && listInductionRecord.size() > 0) {
                ImplementManyFieldsDataSetDuplicateRemovalComReqDto implementManyFieldsDataSetDuplicateRemovalComReqDto_1 = new ImplementManyFieldsDataSetDuplicateRemovalComReqDto();
                if (listInductionRecord != null && !CollectionUtil.isEmpty(listInductionRecord) && listInductionRecord != null && !CollectionUtil.isEmpty(listInductionRecord)) {
                    implementManyFieldsDataSetDuplicateRemovalComReqDto_1.setDataSetDuplicateRemovalList(//objList-to-objLists
                            listInductionRecord.stream().map(item -> {
                                DataSetDuplicateRemovalDto elm = new DataSetDuplicateRemovalDto();
                                elm.setCommPrimaryKey(item.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:288064_2_57289
                                elm.setCustomField1(item.getUserId());//SimpleFieldAssign//sourceId:288065_2_57289
                                return elm;
                            }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1438673_1_57289
                }

                /*D2执行多字段数据集记录去重(公共)[7323]   */

                implementManyFieldsDataSetDuplicateRemovalComRespDto_2 = interfaceModeService.implementManyFieldsDataSetDuplicateRemovalCom(implementManyFieldsDataSetDuplicateRemovalComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


            }
            ImplementTwoDataRemovalExistsComRespDto implementTwoDataRemovalExistsComRespDto = null;
            if (implementManyFieldsDataSetDuplicateRemovalComRespDto != null && implementManyFieldsDataSetDuplicateRemovalComRespDto_2 != null) {
                ImplementTwoDataRemovalExistsComReqDto implementTwoDataRemovalExistsComReqDto = new ImplementTwoDataRemovalExistsComReqDto();
                if (implementManyFieldsDataSetDuplicateRemovalComRespDto != null && implementManyFieldsDataSetDuplicateRemovalComRespDto.getDataSetDuplicateRemovalList() != null && !CollectionUtil.isEmpty(implementManyFieldsDataSetDuplicateRemovalComRespDto.getDataSetDuplicateRemovalList())) {
                    implementTwoDataRemovalExistsComReqDto.setDataSetsListOne(//objList-to-objLists
                            implementManyFieldsDataSetDuplicateRemovalComRespDto.getDataSetDuplicateRemovalList().stream().map(item -> {
                                DataSetsListOneDto elm = new DataSetsListOneDto();
                                if (item != null) {
                                    elm.setCustomField(item.getCommPrimaryKey());//SimpleFieldAssign//sourceId:288144_2_57291
                                    elm.setCustomField1(item.getCustomField1());//SimpleFieldAssign//sourceId:288145_2_57291
                                }
                                return elm;
                            }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1438913_1_57291
                }
                if (implementManyFieldsDataSetDuplicateRemovalComRespDto_2 != null && implementManyFieldsDataSetDuplicateRemovalComRespDto_2.getDataSetDuplicateRemovalList() != null && !CollectionUtil.isEmpty(implementManyFieldsDataSetDuplicateRemovalComRespDto_2.getDataSetDuplicateRemovalList())) {
                    implementTwoDataRemovalExistsComReqDto.setDataSetsListTwo(//objList-to-objLists
                            implementManyFieldsDataSetDuplicateRemovalComRespDto_2.getDataSetDuplicateRemovalList().stream().map(item -> {
                                DataSetsListTwoDto elm = new DataSetsListTwoDto();
                                if (item != null) {
                                    elm.setCustomField(item.getCommPrimaryKey());//SimpleFieldAssign//sourceId:288146_2_57291
                                    elm.setCustomField1(item.getCustomField1());//SimpleFieldAssign//sourceId:288147_2_57291
                                }
                                return elm;
                            }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1438914_1_57291
                }

                /*D2执行两数据集去除已存在(公共)[5347]   */

                implementTwoDataRemovalExistsComRespDto = interfaceModeService.implementTwoDataRemovalExistsCom(implementTwoDataRemovalExistsComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


            }
            if ((implementTwoDataRemovalExistsComRespDto != null && implementTwoDataRemovalExistsComRespDto.getTwoDataRemovalExistsList() != null && implementTwoDataRemovalExistsComRespDto.getTwoDataRemovalExistsList().size() > 0)) {
                //if(D2过滤本次退出保留的成员数据集.两数据集去除已存在列表数据集条数 大于 0)  57292

//ModelCode: receptionService
                QueryReceiveFieldDetailRespDto receptionServiceRes_2 = null;
                if (implementTwoDataRemovalExistsComRespDto != null) {
                    QueryReceiveFieldDetailReqDto receptionServiceReq_1 = new QueryReceiveFieldDetailReqDto();
                    if (implementTwoDataRemovalExistsComRespDto != null && implementTwoDataRemovalExistsComRespDto.getTwoDataRemovalExistsList() != null && !CollectionUtil.isEmpty(implementTwoDataRemovalExistsComRespDto.getTwoDataRemovalExistsList())) {
                        receptionServiceReq_1.setOrgInductionRecordList(//objList-to-objLists
                                implementTwoDataRemovalExistsComRespDto.getTwoDataRemovalExistsList().stream().map(item -> {
                                    OrgInductionRecordDto elm = new OrgInductionRecordDto();
                                    if (item != null) {
                                        elm.setOriginalRoleMemberId(item.getCustomField());//SimpleFieldAssign//sourceId:288136_2_57293
                                        elm.setUserId(item.getCustomField1());//SimpleFieldAssign//sourceId:288137_2_57293
                                    }
                                    return elm;
                                }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1438896_1_57293
                    }

                    /*M1接收就职记录数据集入参[3715]  用于特殊方法接收上游入参。 */

                    receptionServiceRes_2 = nbMember.queryReceiveFieldDetail(receptionServiceReq_1);


                }
                //ModelCode: circulationCollections
                for (OrgInductionRecordDto circulationCollectionsRes_2 : receptionServiceRes_2.getOrgInductionRecordList()) {

                    ImplementMemberChannelExitProcessComRespDto implementMemberChannelExitProcessComRespDto = null;
                    if (organization_2 != null) {
                        ImplementMemberChannelExitProcessComReqDto implementMemberChannelExitProcessComReqDto = new ImplementMemberChannelExitProcessComReqDto();
                        implementMemberChannelExitProcessComReqDto.setChannelTypeCode("ORG_GROUP");//sourceId:1438923_1_57296
                        implementMemberChannelExitProcessComReqDto.setIsSaveData("TRUE");//sourceId:1438928_1_57296
                        if (circulationCollectionsRes_2 != null) {
                            implementMemberChannelExitProcessComReqDto.setOriginalRoleMemberId(circulationCollectionsRes_2.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1438924_1_57296
                            implementMemberChannelExitProcessComReqDto.setUserId(circulationCollectionsRes_2.getUserId());//SimpleFieldAssign//sourceId:1438925_1_57296
                        }
                        if (organization_2 != null) {
                            implementMemberChannelExitProcessComReqDto.setEntityId(organization_2.getOrganizationId());//SimpleFieldAssign//sourceId:1438922_1_57296
                        }
                        if (reqDto != null) {
                            implementMemberChannelExitProcessComReqDto.setMessageLocationCode(reqDto.getMessageLocationCode());//SimpleFieldAssign//sourceId:1438927_1_57296
                            implementMemberChannelExitProcessComReqDto.setBorcScene(reqDto.getBorcScene());//SimpleFieldAssign//sourceId:1438926_1_57296
                        }

                        /*D2执行成员通道关系退出处理(公共)[8191]   */
                        Assert.isNull(implementMemberChannelExitProcessComReqDto.getOriginalRoleMemberId(), "D1执行组织群成员通道关系处理(公共)-D2执行成员通道关系退出处理(公共)-身份人员ID不能为空", false);
                        Assert.isNull(implementMemberChannelExitProcessComReqDto.getUserId(), "D1执行组织群成员通道关系处理(公共)-D2执行成员通道关系退出处理(公共)-个人账号ID不能为空", false);
                        Assert.isNull(implementMemberChannelExitProcessComReqDto.getEntityId(), "D1执行组织群成员通道关系处理(公共)-D2执行成员通道关系退出处理(公共)-归属主体内容ID不能为空", false);
                        Assert.isNull(implementMemberChannelExitProcessComReqDto.getChannelTypeCode(), "D1执行组织群成员通道关系处理(公共)-D2执行成员通道关系退出处理(公共)-通道类型编码不能为空", false);
                        Assert.isNull(implementMemberChannelExitProcessComReqDto.getIsSaveData(), "D1执行组织群成员通道关系处理(公共)-D2执行成员通道关系退出处理(公共)-是否退出保留不能为空", false);
                        Assert.isNull(implementMemberChannelExitProcessComReqDto.getMessageLocationCode(), "D1执行组织群成员通道关系处理(公共)-D2执行成员通道关系退出处理(公共)-消息位置标识不能为空", false);
                        Assert.isNull(implementMemberChannelExitProcessComReqDto.getBorcScene(), "D1执行组织群成员通道关系处理(公共)-D2执行成员通道关系退出处理(公共)-toB或toC场景不能为空", false);
                        implementMemberChannelExitProcessComRespDto = fwCompMessageClient.implementMemberChannelExitProcessCom(implementMemberChannelExitProcessComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


                    }
//ModelCode: circulationEnd
                }

            }
        }
        ImplementOrgGroupMemberChannelExitProcessComRespDto retData = new ImplementOrgGroupMemberChannelExitProcessComRespDto();


        return retData;
    }

    /**
     * D1查询身份人员详情(公共)[8791]
     * gen by moon at 3/27/2024, 1:41:20 PM
     */
    @Trace(operationName = "D1查询身份人员详情(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryBeginMemberDetailComRespDto queryBeginMemberDetailCom(QueryBeginMemberDetailComReqDto reqDto) {


        OriginalRoleMember originalRoleMember_1 = null;
//步骤0: 1-2-09查询身份人员详情 - queryBeginMemberDetail
        OriginalRoleMember originalRoleMember = null;
        QueryBeginMemberDetailReq queryBeginMemberDetailReq = new QueryBeginMemberDetailReq();
        if (reqDto != null) {
            queryBeginMemberDetailReq.setOriginalRoleMemberId(reqDto.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1658932_1
            queryBeginMemberDetailReq.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1658935_1
            queryBeginMemberDetailReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1658950_1
        }

        /*1-2-09查询身份人员详情[174]   */
        Assert.isNull(queryBeginMemberDetailReq.getOriginalRoleMemberId(), "D1查询身份人员详情(公共)-1-2-09查询身份人员详情-身份人员ID不能为空", false);
        Assert.isNull(queryBeginMemberDetailReq.getSubjectLifeCycle(), "D1查询身份人员详情(公共)-1-2-09查询身份人员详情-主体生命周期不能为空", false);
        Assert.isNull(queryBeginMemberDetailReq.getSpaceId(), "D1查询身份人员详情(公共)-1-2-09查询身份人员详情-创建于空间ID不能为空", false);
        originalRoleMember = mOriginalRoleMemberService.queryBeginMemberDetail(queryBeginMemberDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        originalRoleMember_1 = originalRoleMember;

        QueryBeginMemberDetailComRespDto retData = new QueryBeginMemberDetailComRespDto();
        if (originalRoleMember_1 != null) {
            retData.setOriginalRoleMemberId(originalRoleMember_1.getOriginalRoleMemberId());//SimpleFieldAssign//sourceId:1659089_1
            retData.setUserId(originalRoleMember_1.getUserId());//SimpleFieldAssign//sourceId:1658957_1
            retData.setMemberId(originalRoleMember_1.getMemberId());//SimpleFieldAssign//sourceId:1658958_1
        }


        return retData;
    }

    /**
     * D1查询空间成员详情(公共)[8820]
     * gen by moon at 3/27/2024, 10:30:41 PM
     */
    @Trace(operationName = "D1查询空间成员详情(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryMemberDetailComRespDto queryMemberDetailCom(QueryMemberDetailComReqDto reqDto) {


        SpaceMember spaceMember_1 = null;
//步骤0: 1-2-05查询空间成员关系详情 - queryMemberDetail
        SpaceMember spaceMember = null;
        QueryMemberDetailReq queryMemberDetailReq = new QueryMemberDetailReq();
        if (reqDto != null) {
            queryMemberDetailReq.setUserId(reqDto.getUserId());//SimpleFieldAssign//sourceId:1660487_1
            queryMemberDetailReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1660488_1
        }

        /*1-2-05查询空间成员关系详情[167]   */
        Assert.isNull(queryMemberDetailReq.getUserId(), "D1查询空间成员详情(公共)-1-2-05查询空间成员关系详情-成员个人账号不能为空", false);
        Assert.isNull(queryMemberDetailReq.getSpaceId(), "D1查询空间成员详情(公共)-1-2-05查询空间成员关系详情-创建于空间ID不能为空", false);
        spaceMember = mSpaceMemberService.queryMemberDetail(queryMemberDetailReq)/*vcase invoke 本地 method 方法调用;*/;


        spaceMember_1 = spaceMember;

        QueryMemberDetailComRespDto retData = new QueryMemberDetailComRespDto();
        if (spaceMember_1 != null) {
            retData.setMemberId(spaceMember_1.getMemberId());//SimpleFieldAssign//sourceId:1660491_1
        }


        return retData;
    }
    //
}
